accounts 0.6.7 → 0.7.0

package/src/server/internal/handlers/feePayer.test.ts

@@ -1,336 +0,0 @@
-import type { RpcRequest } from 'ox'
-import { SignatureEnvelope, Transaction as core_Transaction, TxEnvelopeTempo } from 'ox/tempo'
-import { parseUnits } from 'viem'
-import { sendTransaction, sendTransactionSync, waitForTransactionReceipt } from 'viem/actions'
-import { Actions, Transaction, withFeePayer } from 'viem/tempo'
-import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vp/test'
-
-import { accounts, addresses, chain, getClient, http } from '../../../../test/config.js'
-import { createServer, type Server } from '../../../../test/utils.js'
-import { feePayer } from './feePayer.js'
-
-const userAccount = accounts[9]!
-const feePayerAccount = accounts[0]!
-
-let server: Server
-let fp: ReturnType<typeof getClient>
-let requests: RpcRequest.RpcRequest[] = []
-
-beforeAll(async () => {
-  server = await createServer(
-    feePayer({
-      account: feePayerAccount,
-      chains: [chain],
-      transports: { [chain.id]: http() },
-      onRequest: async (request) => {
-        requests.push(request)
-      },
-    }).listener,
-  )
-  fp = getClient({ transport: http(server.url) })
-})
-
-afterAll(() => {
-  server.close()
-  process.on('SIGINT', () => {
-    server.close()
-    process.exit(0)
-  })
-  process.on('SIGTERM', () => {
-    server.close()
-    process.exit(0)
-  })
-})
-
-afterEach(() => {
-  requests = []
-})
-
-/** Signs a sponsor-bound Tempo transaction, preserving the feePayerSignature. */
-async function signSponsoredTx(account: (typeof accounts)[number], transaction: object) {
-  const serialized = (await Transaction.serialize(transaction as never)) as `0x76${string}`
-  const envelope = TxEnvelopeTempo.deserialize(serialized)
-  const signature = await account.sign({
-    hash: TxEnvelopeTempo.getSignPayload(envelope),
-  })
-  return TxEnvelopeTempo.serialize(envelope, {
-    signature: SignatureEnvelope.from(signature),
-  })
-}
-
-describe('POST /', () => {
-  test('default: eth_fillTransaction returns a sponsor-bound transaction the sender can broadcast', async () => {
-    const response = (await fp.request({
-      method: 'eth_fillTransaction',
-      params: [
-        {
-          chainId: chain.id,
-          feePayer: true,
-          from: userAccount.address,
-          to: '0x0000000000000000000000000000000000000000',
-        },
-      ],
-    })) as {
-      sponsor: { address: string }
-      tx: Record<string, unknown>
-    }
-    const prepared = core_Transaction.fromRpc(response.tx as never) as {
-      feePayerSignature?: unknown
-    }
-    const signed = await signSponsoredTx(userAccount, prepared)
-    const receipt = (await getClient().request({
-      method: 'eth_sendRawTransactionSync',
-      params: [signed],
-    })) as { feePayer?: string | undefined }
-
-    expect(response.sponsor.address).toBe(feePayerAccount.address)
-    expect(prepared?.feePayerSignature).toBeDefined()
-    expect(receipt.feePayer).toBe(feePayerAccount.address.toLowerCase())
-    expect(requests.map(({ method }) => method)).toMatchInlineSnapshot(`
-      [
-        "eth_fillTransaction",
-      ]
-    `)
-  })
-
-  test('behavior: mutating a sponsor-bound transaction invalidates the fee payer binding', async () => {
-    const response = (await fp.request({
-      method: 'eth_fillTransaction',
-      params: [
-        {
-          chainId: chain.id,
-          feePayer: true,
-          from: userAccount.address,
-          to: '0x0000000000000000000000000000000000000000',
-        },
-      ],
-    })) as { tx: Record<string, unknown> }
-    const prepared = core_Transaction.fromRpc(response.tx as never) as {
-      gas?: bigint | undefined
-      feePayerSignature?: unknown
-    }
-    const signed = await signSponsoredTx(userAccount, {
-      ...prepared,
-      gas: (prepared?.gas ?? 0n) + 1n,
-    })
-
-    await expect(
-      getClient().request({
-        method: 'eth_sendRawTransactionSync',
-        params: [signed],
-      }),
-    ).rejects.toThrowError()
-  })
-
-  test('behavior: eth_signRawTransaction', async () => {
-    const client = getClient({
-      account: userAccount,
-      transport: withFeePayer(http(), http(server.url)),
-    })
-
-    const receipt = await sendTransactionSync(client, {
-      feePayer: true,
-      to: '0x0000000000000000000000000000000000000000',
-    })
-
-    expect(receipt.feePayer).toBe(feePayerAccount.address.toLowerCase())
-
-    expect(requests.map(({ method }) => method)).toMatchInlineSnapshot(`
-      [
-        "eth_signRawTransaction",
-      ]
-    `)
-  })
-
-  test('behavior: eth_sendRawTransaction', async () => {
-    const client = getClient({
-      account: userAccount,
-      transport: withFeePayer(http(), http(server.url), {
-        policy: 'sign-and-broadcast',
-      }),
-    })
-
-    const hash = await sendTransaction(client, {
-      feePayer: true,
-      to: '0x0000000000000000000000000000000000000001',
-    })
-    const receipt = await waitForTransactionReceipt(getClient(), { hash })
-
-    expect(receipt.feePayer).toBe(feePayerAccount.address.toLowerCase())
-
-    expect(requests.map(({ method }) => method)).toMatchInlineSnapshot(`
-      [
-        "eth_sendRawTransaction",
-      ]
-    `)
-  })
-
-  test('behavior: eth_sendRawTransactionSync', async () => {
-    const client = getClient({
-      account: userAccount,
-      transport: withFeePayer(http(), http(server.url), {
-        policy: 'sign-and-broadcast',
-      }),
-    })
-
-    const receipt = await sendTransactionSync(client, {
-      feePayer: true,
-      to: '0x0000000000000000000000000000000000000002',
-    })
-
-    expect(receipt.feePayer).toBe(feePayerAccount.address.toLowerCase())
-
-    expect(requests.map(({ method }) => method)).toMatchInlineSnapshot(`
-      [
-        "eth_sendRawTransactionSync",
-      ]
-    `)
-  })
-
-  test('behavior: unsupported method', async () => {
-    await expect(fp.request({ method: 'eth_chainId' })).rejects.toThrowError()
-  })
-
-  test('behavior: internal error', async () => {
-    await expect(
-      fp.request({
-        method: 'eth_signRawTransaction' as never,
-        params: ['0xinvalid'],
-      }),
-    ).rejects.toThrowError()
-  })
-})
-
-describe('behavior: conditional sponsoring', () => {
-  const rejectedAccount = accounts[3]!
-  let conditionalServer: Server
-  let conditionalFp: ReturnType<typeof getClient>
-
-  beforeAll(async () => {
-    // Fund accounts with alphaUsd for transfers + fee payment.
-    const rpc = getClient()
-    await Actions.token.mintSync(rpc, {
-      account: accounts[0]!,
-      token: addresses.alphaUsd,
-      amount: parseUnits('100', 6),
-      to: userAccount.address,
-    })
-    await Actions.fee.setUserToken(rpc, { account: userAccount, token: addresses.alphaUsd })
-    await Actions.token.mintSync(rpc, {
-      account: accounts[0]!,
-      token: addresses.alphaUsd,
-      amount: parseUnits('100', 6),
-      to: rejectedAccount.address,
-    })
-    await Actions.fee.setUserToken(rpc, { account: rejectedAccount, token: addresses.alphaUsd })
-
-    conditionalServer = await createServer(
-      feePayer({
-        account: feePayerAccount,
-        chains: [chain],
-        transports: { [chain.id]: http() },
-        validate: (request) =>
-          request.from?.toLowerCase() !== rejectedAccount.address.toLowerCase(),
-      }).listener,
-    )
-    conditionalFp = getClient({ transport: http(conditionalServer.url) })
-  })
-
-  afterAll(() => {
-    conditionalServer.close()
-  })
-
-  test('behavior: approved tx is sponsored and can be broadcast', async () => {
-    const { data, to } = Actions.token.transfer.call({
-      token: addresses.alphaUsd,
-      to: rejectedAccount.address,
-      amount: 1n,
-    })
-    const response = (await conditionalFp.request({
-      method: 'eth_fillTransaction',
-      params: [
-        {
-          chainId: chain.id,
-          feePayer: true,
-          from: userAccount.address,
-          to,
-          data,
-        },
-      ],
-    })) as { sponsor?: { address: string }; tx: Record<string, unknown> }
-
-    const prepared = core_Transaction.fromRpc(response.tx as never) as {
-      feePayerSignature?: unknown
-    }
-    expect(prepared.feePayerSignature).toBeDefined()
-    expect(response.sponsor?.address).toBe(feePayerAccount.address)
-
-    const signed = await signSponsoredTx(userAccount, prepared)
-    const receipt = (await getClient().request({
-      method: 'eth_sendRawTransactionSync',
-      params: [signed],
-    })) as { feePayer?: string | undefined }
-
-    expect(receipt.feePayer).toBe(feePayerAccount.address.toLowerCase())
-  })
-
-  test('behavior: rejected tx is not sponsored and can be self-paid', async () => {
-    const { data, to } = Actions.token.transfer.call({
-      token: addresses.alphaUsd,
-      to: userAccount.address,
-      amount: 1n,
-    })
-    const response = (await conditionalFp.request({
-      method: 'eth_fillTransaction',
-      params: [
-        {
-          chainId: chain.id,
-          feePayer: true,
-          from: rejectedAccount.address,
-          to,
-          data,
-        },
-      ],
-    })) as { sponsor?: { address: string }; tx: Record<string, unknown> }
-
-    const prepared = core_Transaction.fromRpc(response.tx as never) as {
-      feePayerSignature?: unknown
-    }
-    expect(prepared.feePayerSignature).toBeUndefined()
-    expect(response.sponsor).toBeUndefined()
-
-    const signed = await signSponsoredTx(rejectedAccount, prepared)
-    const receipt = (await getClient().request({
-      method: 'eth_sendRawTransactionSync',
-      params: [signed],
-    })) as { feePayer?: string | undefined }
-
-    // Sender pays their own fee — no external fee payer.
-    expect(receipt.feePayer).not.toBe(feePayerAccount.address.toLowerCase())
-  })
-
-  test('behavior: rejected raw transaction returns error', async () => {
-    // First fill without the conditional server to get a signed tx.
-    const response = (await fp.request({
-      method: 'eth_fillTransaction',
-      params: [
-        {
-          chainId: chain.id,
-          feePayer: true,
-          from: rejectedAccount.address,
-          to: '0x0000000000000000000000000000000000000000',
-        },
-      ],
-    })) as { tx: Record<string, unknown> }
-    const prepared = core_Transaction.fromRpc(response.tx as never)
-    const signed = await signSponsoredTx(rejectedAccount, prepared)
-
-    // Submit the signed tx to the conditional server — should reject.
-    await expect(
-      conditionalFp.request({
-        method: 'eth_signRawTransaction' as never,
-        params: [signed],
-      }),
-    ).rejects.toThrowError()
-  })
-})

package/src/server/internal/handlers/feePayer.ts

@@ -1,271 +0,0 @@
-import { RpcRequest, RpcResponse, Signature } from 'ox'
-import { Transaction as core_Transaction, TxEnvelopeTempo } from 'ox/tempo'
-import type { Address, Chain, Client, Transport } from 'viem'
-import { createClient, http } from 'viem'
-import type { LocalAccount } from 'viem/accounts'
-import { signTransaction } from 'viem/actions'
-import { tempo, tempoModerato } from 'viem/chains'
-import { Transaction } from 'viem/tempo'
-
-import { type Handler, from } from '../../Handler.js'
-import * as Utils from './utils.js'
-
-/**
- * Instantiates a fee payer service request handler that can be used to
- * sponsor the fee for user transactions.
- *
- * @example
- * ```ts
- * import { privateKeyToAccount } from 'viem/accounts'
- * import { Handler } from 'accounts/server'
- *
- * const handler = Handler.feePayer({
- *   account: privateKeyToAccount('0x...'),
- * })
- *
- * // Plug handler into your server framework of choice:
- * createServer(handler.listener)              // Node.js
- * Bun.serve(handler)                          // Bun
- * Deno.serve(handler)                         // Deno
- * app.use(handler.listener)                   // Express
- * app.all('*', c => handler.fetch(c.req.raw)) // Hono
- * export const GET = handler.fetch            // Next.js
- * export const POST = handler.fetch           // Next.js
- * ```
- *
- * @param options - Options.
- * @returns Request handler.
- */
-export function feePayer(options: feePayer.Options): Handler {
-  const {
-    account,
-    chains = [tempo, tempoModerato],
-    name,
-    onRequest,
-    path = '/',
-    validate,
-    transports = {},
-    url,
-    ...rest
-  } = options
-
-  const clients = new Map<number, Client>()
-  for (const chain of chains) {
-    const transport = transports[chain.id] ?? http()
-    clients.set(chain.id, createClient({ chain, transport }))
-  }
-
-  function getClient(chainId?: number): Client {
-    if (chainId) {
-      const client = clients.get(chainId)
-      if (!client) throw new Error(`Chain ${chainId} not configured`)
-      return client
-    }
-    return clients.get(chains[0]!.id)!
-  }
-
-  const sponsor = {
-    address: account.address,
-    ...(name ? { name } : {}),
-    ...(url ? { url } : {}),
-  }
-
-  const router = from(rest)
-
-  router.post(path, async (c) => {
-    const request = RpcRequest.from((await c.req.raw.json()) as any)
-
-    try {
-      await onRequest?.(request)
-
-      const method = request.method as string
-      if (
-        method !== 'eth_fillTransaction' &&
-        method !== 'eth_signRawTransaction' &&
-        method !== 'eth_sendRawTransaction' &&
-        method !== 'eth_sendRawTransactionSync'
-      )
-        return Response.json(
-          RpcResponse.from(
-            {
-              error: new RpcResponse.MethodNotSupportedError({
-                message: `Method not supported: ${request.method}`,
-              }),
-            },
-            { request },
-          ),
-        )
-
-      if (method === 'eth_fillTransaction') {
-        const [parameters] = Utils.parseParams.parse(request.params) as [Record<string, unknown>]
-        const chainId = Utils.resolveChainId(parameters.chainId)
-        const client = getClient(chainId)
-        const normalized = Utils.normalizeFillTransactionRequest(parameters)
-        const sender =
-          typeof parameters.from === 'string' ? (parameters.from as Address) : undefined
-
-        let transaction = await (async () => {
-          if (isPreparedFeePayerTransaction(parameters))
-            return Utils.normalizeTempoTransaction(parameters)
-
-          const fillRequest = Utils.formatFillTransactionRequest(client, {
-            ...normalized,
-            ...(typeof chainId !== 'undefined' ? { chainId } : {}),
-            feePayer: true,
-          })
-          const result = (await client.request({
-            method: 'eth_fillTransaction' as never,
-            params: [fillRequest],
-          })) as { tx?: Record<string, unknown> | undefined }
-          return Utils.normalizeTempoTransaction(result.tx)
-        })()
-
-        if (
-          validate &&
-          // @ts-expect-error - TODO: Convert to `TransactionRequest` properly.
-          !(await validate({
-            ...transaction,
-            from: sender,
-          } as Transaction.TransactionRequest))
-        ) {
-          // Re-fill without feePayer so gas/nonce are correct for self-payment.
-          const fillRequest = Utils.formatFillTransactionRequest(client, {
-            ...normalized,
-            ...(typeof chainId !== 'undefined' ? { chainId } : {}),
-          })
-          const result = (await client.request({
-            method: 'eth_fillTransaction' as never,
-            params: [fillRequest],
-          })) as { tx?: Record<string, unknown> | undefined }
-          transaction = Utils.normalizeTempoTransaction(result.tx)
-
-          return Utils.rpcResult(request, {
-            tx: core_Transaction.toRpc(transaction as core_Transaction.Transaction),
-          })
-        }
-
-        const signed = await sign({ account, transaction, sender })
-
-        return Utils.rpcResult(request, {
-          sponsor,
-          tx: core_Transaction.toRpc(signed as core_Transaction.Transaction),
-        })
-      }
-
-      const serialized = request.params?.[0] as `0x76${string}` | undefined
-
-      if (!serialized?.startsWith('0x76') && !serialized?.startsWith('0x78'))
-        throw new RpcResponse.InvalidParamsError({
-          message: 'Only Tempo (0x76/0x78) transactions are supported.',
-        })
-
-      const transaction = Transaction.deserialize(serialized)
-
-      if (!transaction.signature || !transaction.from)
-        throw new RpcResponse.InvalidParamsError({
-          message: 'Transaction must be signed by the sender before fee payer signing.',
-        })
-
-      if (validate && !(await validate(transaction as Transaction.TransactionRequest)))
-        throw new RpcResponse.InvalidParamsError({
-          message: 'Sponsorship rejected.',
-        })
-
-      const client = getClient(transaction.chainId)
-      const serializedTransaction = toSerializedTransaction(
-        await signTransaction(client, {
-          ...transaction,
-          account,
-          feePayer: account,
-        } as never),
-      )
-
-      if (method === 'eth_signRawTransaction')
-        return Response.json(RpcResponse.from({ result: serializedTransaction }, { request }))
-
-      const result = await client.request({
-        method: method as never,
-        params: [serializedTransaction],
-      })
-
-      return Response.json(RpcResponse.from({ result }, { request }))
-    } catch (error) {
-      return Utils.rpcError(request, error)
-    }
-  })
-
-  return router
-}
-
-export declare namespace feePayer {
-  type Options = from.Options & {
-    /** Account to use as the fee payer. */
-    account: LocalAccount
-    /**
-     * Supported chains. The handler resolves the client based on the
-     * `chainId` in the incoming transaction.
-     * @default [tempo, tempoModerato]
-     */
-    chains?: readonly [Chain, ...Chain[]] | undefined
-    /** Function to call before handling the request. */
-    onRequest?: (request: RpcRequest.RpcRequest) => Promise<void>
-    /** Path to use for the handler. */
-    path?: string | undefined
-    /**
-     * Validates whether to sponsor the transaction. When omitted, all
-     * transactions are sponsored. Return `false` to reject sponsorship.
-     */
-    validate?: ((request: Transaction.TransactionRequest) => boolean | Promise<boolean>) | undefined
-    /** Sponsor display name returned from `eth_fillTransaction`. */
-    name?: string | undefined
-    /** Transports keyed by chain ID. Defaults to `http()` for each chain. */
-    transports?: Record<number, Transport> | undefined
-    /** Sponsor URL returned from `eth_fillTransaction`. */
-    url?: string | undefined
-  }
-}
-
-/** Signs a filled transaction as the fee payer. */
-export async function sign(options: {
-  account: LocalAccount
-  transaction: Record<string, unknown>
-  sender?: `0x${string}` | undefined
-}) {
-  const { account, transaction, sender } = options
-  const from = (transaction.from as `0x${string}` | undefined) ?? sender
-  const { signature: _, ...withoutSenderSig } = transaction
-  const prepared = { ...withoutSenderSig, from }
-
-  if (!prepared.from)
-    throw new RpcResponse.InvalidParamsError({
-      message: 'Transaction sender must be provided before fee payer signing.',
-    })
-  if (!account.sign) throw new Error('Fee payer account cannot sign transactions.')
-
-  const feePayerSignature = Signature.from(
-    await account.sign({
-      hash: TxEnvelopeTempo.getFeePayerSignPayload(TxEnvelopeTempo.from(prepared as never), {
-        sender: prepared.from,
-      }),
-    }),
-  )
-
-  return { ...prepared, feePayerSignature }
-}
-
-function isPreparedFeePayerTransaction(value: Record<string, unknown>) {
-  return (
-    typeof value.from === 'string' &&
-    typeof Utils.resolveChainId(value.chainId) === 'number' &&
-    typeof value.gas !== 'undefined' &&
-    typeof value.nonce !== 'undefined' &&
-    (typeof value.maxFeePerGas !== 'undefined' || typeof value.gasPrice !== 'undefined')
-  )
-}
-
-function toSerializedTransaction(value: unknown) {
-  if (typeof value === 'string') return value
-  if (value && typeof value === 'object' && 'raw' in value && typeof value.raw === 'string')
-    return value.raw
-  throw new Error('Expected a serialized transaction result.')
-}