Cheatsheet

import { Effect, Layer, Schedule } from 'effect'
import * as S from 'effect/Schema'
import * as Address from 'voltaire-effect/primitives/Address'
import { getBalance, getBlockNumber, getBlock, Provider, HttpTransport, withTimeout, withRetrySchedule } from 'voltaire-effect'

import { Layer } from 'effect'

const ProviderLayer = Provider.pipe(
  Layer.provide(HttpTransport('https://eth.llamarpc.com'))
)

const program = Effect.gen(function* () {
  const addr = yield* S.decode(Address.Hex)(input)     // decode
  return yield* getBalance(addr, 'latest')             // use free function
})

await Effect.runPromise(program.pipe(Effect.provide(ProviderLayer)))

program.pipe(
  Effect.catchTag('ParseError', (e) => Effect.succeed(fallback)),
  Effect.catchTag('TransportError', (e) => Effect.succeed(0n)),
  Effect.catchTags({
    ParseError: () => ...,
    TransportError: () => ...,
    ProviderResponseError: () => ...,
  })
)

const program = Effect.gen(function* () {
  // Use free functions instead of yielding ProviderService
  const balance = yield* getBalance(addr)
  const block = yield* getBlockNumber()

  // For signer, still use the service
  const signer = yield* SignerService
})

// Provider layer
const ProviderLayer = Provider.pipe(
  Layer.provide(HttpTransport('https://eth.llamarpc.com'))
)

// Full signer layer with crypto
const CryptoLayer = Layer.mergeAll(Secp256k1Live, KeccakLive)
const SignerLayer = Layer.mergeAll(
  Signer.Live,
  CryptoLayer,
  ProviderLayer
).pipe(Layer.provideMerge(LocalAccount(privateKey)))

// Provide once at the edge
await Effect.runPromise(program.pipe(Effect.provide(SignerLayer)))

import {
  getBlockNumber, getBalance, getBlock, getTransaction,
  getTransactionReceipt, getLogs, call, estimateGas
} from 'voltaire-effect'

yield* getBlockNumber()
yield* getBalance(addr, 'latest')
yield* getBlock({ blockTag: 'latest' })
yield* getTransaction(txHash)
yield* getTransactionReceipt(txHash)
yield* getLogs({ address, topics, fromBlock, toBlock })
yield* call({ to, data })
yield* estimateGas({ to, data, value })

const signer = yield* SignerService

yield* signer.sendTransaction({ to, value: 1000000000000000000n })
yield* signer.signMessage(Hex.fromString('Hello'))
yield* signer.signTypedData(typedData)

const token = yield* Contract(address, erc20Abi)

yield* token.read.balanceOf(user)
yield* token.write.transfer(to, amount)
yield* token.simulate.transfer(to, amount)
yield* token.getEvents('Transfer', { fromBlock, toBlock })

import { getBlockNumber, getBalance, getChainId } from 'voltaire-effect'

// Named effects - use object notation for self-documenting code
const { blockNumber, balance, chainId } = yield* Effect.all({
  blockNumber: getBlockNumber(),
  balance: getBalance(addr),
  chainId: getChainId()
})

// Transform collection - use Effect.forEach (NOT Effect.all with .map)
yield* Effect.forEach(addresses, (addr) => getBalance(addr))

// With concurrency
yield* Effect.forEach(addresses, (addr) => getBalance(addr), { concurrency: 5 })

// With index
yield* Effect.forEach(items, (item, index) => processItem(item, index))

// Discard results (side effects only)
yield* Effect.forEach(items, (item) => logItem(item), { discard: true })

import { Effect, Schedule } from 'effect'
import { getBalance, withTimeout, withRetrySchedule } from 'voltaire-effect'

// Per-request overrides (preferred)
getBalance(addr).pipe(withTimeout("5 seconds"))
getBalance(addr).pipe(withRetrySchedule(Schedule.recurs(1)))

// Exponential backoff with jitter
getBalance(addr).pipe(
  withRetrySchedule(
    Schedule.exponential("500 millis").pipe(
      Schedule.jittered,
      Schedule.compose(Schedule.recurs(5))
    )
  )
)

import { Stream } from 'effect'
import { makeBlockStream } from 'voltaire-effect/services'

const blockStream = yield* makeBlockStream()
yield* Stream.runForEach(
  blockStream.watch({ include: 'transactions' }),
  (event) => Effect.log(`Block ${event.blocks[0]?.header.number}`)
)

const debug = yield* DebugService
const trace = yield* debug.traceTransaction('0x...')

const engine = yield* EngineApiService
const caps = yield* engine.exchangeCapabilities(['engine_newPayloadV3'])

import { Layer } from 'effect'
import { TestTransport, Provider } from 'voltaire-effect'

// Mock transport layer for testing
const mockTransport = TestTransport({
  eth_blockNumber: () => '0x3039', // 12345
  eth_getBalance: () => '0xde0b6b3a7640000' // 1 ETH
})

// Compose test layer
const TestLayer = Provider.pipe(Layer.provide(mockTransport))

await Effect.runPromise(program.pipe(Effect.provide(TestLayer)))

import { CryptoLive, KeccakService, Secp256k1Service } from 'voltaire-effect/crypto'

const program = Effect.gen(function* () {
  const keccak = yield* KeccakService
  const secp = yield* Secp256k1Service
  
  const hash = yield* keccak.hash(data)
  const sig = yield* secp.sign(hash, privateKey)
}).pipe(Effect.provide(CryptoLive))

import { Schedule } from 'effect'

// HTTP
HttpTransport('https://eth.llamarpc.com')

// HTTP with Duration timeout and Schedule retries
HttpTransport({
  url: '...',
  timeout: '60 seconds',
  retrySchedule: Schedule.exponential('500 millis').pipe(
    Schedule.jittered,
    Schedule.compose(Schedule.recurs(5))
  )
})

// HTTP with batching
HttpTransport({ url: '...', batch: { batchSize: 50, wait: 10 } })

// WebSocket
WebSocketTransport('wss://eth.llamarpc.com')

// Browser (window.ethereum)
BrowserTransport

// Address from hex
const addr = S.decodeSync(Address.Hex)('0x...')

// Hex from string
const hex = Hex.fromString('hello')

// Hex from bytes
const hex = Hex.fromBytes(new Uint8Array([1, 2, 3]))

// Address to hex string
Address.toHex(addr)

// Check zero address
Address.isZero(addr)

// Promise
await Effect.runPromise(effect)

// Sync (throws if async or error)
Effect.runSync(effect)

// Exit (captures success or failure)
const exit = await Effect.runPromiseExit(effect)
Exit.match(exit, { onSuccess: ..., onFailure: ... })