Rate Limiting with Effect.ts

import { Effect, RateLimiter, Function } from "effect"

const program = Effect.gen(function* () {
  // Create a rate limiter: 10 requests per second
  const limiter = yield* RateLimiter.make({
    limit: 10,
    interval: "1 second",
    algorithm: "token-bucket"  // or "fixed-window"
  })
  
  // Apply to any Effect
  const result = yield* limiter(
    Effect.succeed("rate limited operation")
  )
  
  return result
})

import { Effect, RateLimiter, Function } from "effect"

const program = Effect.gen(function* () {
  // Per-second limit
  const perSecond = yield* RateLimiter.make({ 
    limit: 10, 
    interval: "1 second" 
  })
  
  // Per-day limit (many providers have daily quotas)
  const perDay = yield* RateLimiter.make({ 
    limit: 10_000, 
    interval: "1 day" 
  })
  
  // Compose: request must pass BOTH limits
  const composed = Function.compose(perSecond, perDay)
  
  // Apply to operations
  const result = yield* composed(
    Effect.succeed("passes both rate limits")
  )
  
  return result
})

import { Effect, RateLimiter } from "effect"

const program = Effect.gen(function* () {
  const limiter = yield* RateLimiter.make({ 
    limit: 100, 
    interval: "1 second" 
  })
  
  // Standard operation: costs 1 token
  yield* limiter(simpleCall)
  
  // Expensive operation: costs 5 tokens
  yield* limiter(expensiveCall).pipe(
    RateLimiter.withCost(5)
  )
})

import { Effect } from "effect"
import {
  RateLimiterService,
  DefaultRateLimiter,
  HttpTransport,
  getBalance
} from "voltaire-effect"

const program = Effect.gen(function* () {
  const rateLimiter = yield* RateLimiterService
  const address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
  
  // Wrap any RPC call with rate limiting
  const balance = yield* rateLimiter.withRateLimit(
    "eth_getBalance",
    getBalance(address)
  )
  
  return balance
}).pipe(
  Effect.scoped,
  Effect.provide(DefaultRateLimiter({ 
    global: { limit: 10, interval: "1 seconds" } 
  })),
  Effect.provide(HttpTransport("https://eth.llamarpc.com"))
)

import { DefaultRateLimiter } from "voltaire-effect"

const RateLimited = DefaultRateLimiter({
  // Global limit applies to all methods
  global: { 
    limit: 50, 
    interval: "1 seconds",
    algorithm: "token-bucket"
  },
  // Per-method overrides (stacks with global)
  methods: {
    "eth_getLogs": { limit: 5, interval: "1 seconds" },
    "eth_call": { limit: 30, interval: "1 seconds" },
    "debug_traceTransaction": { limit: 1, interval: "5 seconds" }
  }
})

// Delay (default): Queue requests until capacity available
const DelayLayer = DefaultRateLimiter({
  global: { limit: 10, interval: "1 seconds" },
  behavior: "delay"
})

// Fail: Immediately fail with RateLimitError
const FailFastLayer = DefaultRateLimiter({
  global: { limit: 10, interval: "1 seconds" },
  behavior: "fail"
})

import { Effect } from "effect"
import { RateLimiterService, RateLimitError } from "voltaire-effect"

const program = Effect.gen(function* () {
  const rateLimiter = yield* RateLimiterService
  return yield* rateLimiter.withRateLimit("eth_call", someEffect)
}).pipe(
  Effect.catchTag("RateLimitError", (e) => {
    console.log(`Rate limited: ${e.method}`)
    return Effect.succeed(fallbackValue)
  })
)

import { Effect, Layer } from "effect"
import {
  Provider,
  DefaultRateLimiter,
  HttpTransport,
  getBlock
} from "voltaire-effect"

// Infura configuration with safety margin
const InfuraRateLimiter = DefaultRateLimiter({
  global: { limit: 8, interval: "1 seconds" },  // Under 10/sec limit
  methods: {
    "eth_getLogs": { limit: 2, interval: "1 seconds" },
    "debug_traceTransaction": { limit: 1, interval: "5 seconds" }
  },
  behavior: "delay"
})

const InfuraProvider = Layer.mergeAll(Provider, InfuraRateLimiter).pipe(
  Layer.provide(HttpTransport("https://mainnet.infura.io/v3/YOUR_KEY"))
)

// Batch operations respect limits automatically
const fetchBlocks = Effect.gen(function* () {
  const blockNumbers = Array.from({ length: 100 }, (_, i) => i + 1000000)
  
  return yield* Effect.all(
    blockNumbers.map((n) =>
      getBlock({ blockTag: `0x${n.toString(16)}` })
    ),
    { concurrency: "unbounded" }  // Rate limiter handles throttling
  )
}).pipe(
  Effect.scoped,
  Effect.provide(InfuraProvider)
)

declare const make: (options: {
  readonly limit: number
  readonly interval: DurationInput  // "1 second", "500 millis", Duration.seconds(1)
  readonly algorithm?: "token-bucket" | "fixed-window"
}) => Effect.Effect<RateLimiter, never, Scope>

declare const withCost: (cost: number) => <A, E, R>(
  effect: Effect.Effect<A, E, R>
) => Effect.Effect<A, E, R>

declare const DefaultRateLimiter: (config: {
  readonly global?: {
    readonly limit: number
    readonly interval: DurationInput
    readonly algorithm?: "token-bucket" | "fixed-window"
  }
  readonly methods?: Record<string, {
    readonly limit: number
    readonly interval: DurationInput
    readonly algorithm?: "token-bucket" | "fixed-window"
  }>
  readonly behavior?: "delay" | "fail"
}) => Layer.Layer<RateLimiterService>