Handler.relay

import { Handler } from 'accounts/server'
 
const handler = Handler.relay()

createServer(handler.listener) // Node.js
Bun.serve(handler) // Bun
Deno.serve(handler) // Deno
app.all('*', c => handler.fetch(c.request)) // Elysia
app.use(handler.listener) // Express
app.use(c => handler.fetch(c.req.raw)) // Hono
export const GET = handler.fetch // Next.js
export const POST = handler.fetch // Next.js

const result = await provider.request({
  method: 'eth_fillTransaction',
  params: [{
    from: account,
    calls: [{
      to: '0x20c000000000000000000000b9537d11c60e8b50', // USDC.e
      // transfer 100 USDC.e
      data: '0xa9059cbb000000000000000000000000cafebabecafebabecafebabecafebabecafebabe0000000000000000000000000000000000000000000000000000000005f5e100',
    }],
  }],
})
 
result.capabilities.fee
// {
//   amount: '0x6b86',
//   decimals: 6,
//   formatted: '0.027526',
//   symbol: 'USDC.e',
// }

const result = await provider.request({
  method: 'eth_fillTransaction',
  params: [{
    from: account,
    calls: [{
      to: '0x20c000000000000000000000b9537d11c60e8b50', // USDC.e
      // transfer 100 USDC.e (but account has 40)
      data: '0xa9059cbb000000000000000000000000cafebabecafebabecafebabecafebabecafebabe0000000000000000000000000000000000000000000000000000000005f5e100',
    }],
  }],
})
 
result.capabilities.requireFunds
// {
//   amount: '0x3938700',
//   decimals: 6,
//   formatted: '60.000000',
//   token: '0x20c000000000000000000000b9537d11c60e8b50',
//   symbol: 'USDC.e',
// }
 
result.capabilities.balanceDiffs
// {
//   '0x1234567890abcdef1234567890abcdef12345678': [{
//     address: '0x20c000000000000000000000b9537d11c60e8b50',
//     decimals: 6,
//     direction: 'outgoing',
//     formatted: '100.000000',
//     name: 'USDC.e',
//     recipients: ['0xcafebabecafebabecafebabecafebabecafebabe'],
//     symbol: 'USDC.e',
//     value: '0x5f5e100',
//   }],
// }

import { privateKeyToAccount } from 'viem/accounts'
import { Handler } from 'accounts/server'
 
const handler = Handler.relay({
  features: 'all', 
})

import { Handler } from 'accounts/server'
 
const handler = Handler.relay({
  autoSwap: { slippage: 0.02 }, // 2% slippage
})

import { tempo } from 'viem/chains'
import { Handler } from 'accounts/server'
 
const handler = Handler.relay({
  chains: [tempo], 
})

import { Handler } from 'accounts/server'
 
const handler = Handler.relay({
  features: 'all', 
})

import { privateKeyToAccount } from 'viem/accounts'
import { Handler } from 'accounts/server'
 
const handler = Handler.relay({
  feePayer: { 
    account: privateKeyToAccount('0x...'), 
    name: 'My App', 
    url: 'https://myapp.com', 
  }, 
})

import { privateKeyToAccount } from 'viem/accounts'
import { Handler } from 'accounts/server'
 
const blocked = '0x...'
 
const handler = Handler.relay({
  feePayer: {
    account: privateKeyToAccount('0x...'),
    validate: (request) => request.from !== blocked, 
  },
})

import { Handler } from 'accounts/server'
 
const handler = Handler.relay({
  onRequest: async (request) => { 
    console.log('Processing request:', request.method) 
  }, 
})

import { Handler } from 'accounts/server'
 
const handler = Handler.relay({
  path: '/relay', 
})

import { Handler } from 'accounts/server'
 
const handler = Handler.relay({
  resolveTokens: (chainId) => [ 
    { 
      address: '0x20c0000000000000000000000000000000000000', 
      decimals: 6, 
      name: 'pathUSD', 
      symbol: 'pathUSD', 
    }, 
    { 
      address: '0x20c000000000000000000000b9537d11c60e8b50', 
      decimals: 6, 
      name: 'USDC.e', 
      symbol: 'USDC.e', 
    }, 
  ], 
})

import { http } from 'viem'
import { tempo } from 'viem/chains'
import { Handler } from 'accounts/server'
 
const handler = Handler.relay({
  transports: { 
    [tempo.id]: http('https://rpc.tempo.xyz'), 
  }, 
})

type Response = {
  /** Wallet-specific capabilities computed during fill. */
  capabilities: {
    /** Per-account balance diffs from simulation (swap-related diffs excluded). */
    balanceDiffs?: {
      [account: Address]: BalanceDiff[]
    }
    /** Fee estimate for the transaction. */
    fee: {
      /** Raw fee amount in token units (hex-encoded). */
      amount: Hex
      /** Token decimals (e.g. 6). */
      decimals: number
      /** Human-readable fee (e.g. "0.028022"). */
      formatted: string
      /** Token symbol (e.g. "AlphaUSD"). */
      symbol: string
    } | null
    /** AMM swap injected to cover an insufficient balance. */
    autoSwap?: {
      /** Max input amount with slippage. */
      maxIn: SwapAmount
      /** Deficit amount that triggered the swap. */
      minOut: SwapAmount
      /** Slippage tolerance (e.g. 0.05 = 5%). */
      slippage: number
    }
    /** Structured error details when the fill fails (e.g. InsufficientBalance). */
    error?: {
      /** ABI item that caused the error. */
      abiItem: AbiItem
      /** Data that caused the error. */
      data: Hex
      /** Revert error name (e.g. "InsufficientBalance"). */
      errorName: string
      /** Human-readable error message. */
      message: string
    }
    /** Funding requirement when InsufficientBalance is encountered. */
    requireFunds?: {
      /** Deficit amount in token units (hex-encoded). */
      amount: Hex
      /** Token decimals (e.g. 6). */
      decimals: number
      /** Human-readable deficit (e.g. "100.000000"). */
      formatted: string
      /** Token address. */
      token: Address
      /** Token symbol (e.g. "USDC.e"). */
      symbol: string
    }
    /** Sponsor details (when sponsored). */
    sponsor?: { address: Address; name: string; url: string }
    /** Whether the transaction is sponsored by a fee payer. */
    sponsored: boolean
  }
  /** Fully filled transaction. */
  tx: {
    // ...filled tx fields
    /** Resolved fee token used for this transaction. */
    feeToken: Address
  }
}
 
type BalanceDiff = {
  /** Token address. */
  address: Address
  /** Token decimals (e.g. 6). */
  decimals: number
  /** Direction relative to the user. */
  direction: 'incoming' | 'outgoing'
  /** Human-readable formatted amount (e.g. "100.00"). */
  formatted: string
  /** Token name (e.g. "USDC.e"). */
  name: string
  /** Addresses receiving this asset. */
  recipients: readonly Address[]
  /** Token symbol (e.g. "USDC.e"). */
  symbol: string
  /** Token amount (hex-encoded). */
  value: Hex
}
 
type SwapAmount = {
  /** Token decimals. */
  decimals: number
  /** Human-readable formatted amount. */
  formatted: string
  /** Token name (e.g. "AlphaUSD"). */
  name: string
  /** Token symbol (e.g. "AlphaUSD"). */
  symbol: string
  /** Token address. */
  token: Address
  /** Amount (hex-encoded). */
  value: Hex
}