accounts 0.6.1 → 0.6.2

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

@@ -0,0 +1,148 @@
+import type { Chain, Client, Transport } from 'viem'
+import { createClient, http } from 'viem'
+import { tempo, tempoModerato } from 'viem/chains'
+import * as z from 'zod/mini'
+
+import * as CliAuth from '../../CliAuth.js'
+import { type Handler, from } from '../../Handler.js'
+
+/**
+ * Instantiates a generic device-code handler for access-key bootstrap.
+ *
+ * Exposes 4 endpoints:
+ * - `GET /auth/pkce/pending/:code`
+ * - `POST /auth/pkce/code`
+ * - `POST /auth/pkce/poll/:code`
+ * - `POST /auth/pkce`
+ *
+ * @param options - Options.
+ * @returns Request handler.
+ */
+export function codeAuth(options: codeAuth.Options = {}): Handler {
+  const {
+    chains = [tempo, tempoModerato],
+    now,
+    path = '/auth/pkce',
+    policy,
+    random,
+    store = CliAuth.Store.memory(),
+    transports = {},
+    ttlMs,
+    ...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?: bigint | number): Client {
+    if (typeof chainId !== 'undefined') {
+      const id = Number(chainId)
+      const client = clients.get(id)
+      if (!client) throw new Error(`Chain ${id} not configured`)
+      return client
+    }
+    return clients.get(chains[0]!.id)!
+  }
+
+  const router = from(rest)
+
+  router.get(`${path}/pending/:code`, async (c) => {
+    try {
+      const code = c.req.param('code')
+      const result = await CliAuth.pending({
+        code,
+        ...(now ? { now } : {}),
+        store,
+      })
+
+      return Response.json(z.encode(CliAuth.pendingResponse, result))
+    } catch (error) {
+      const status = error instanceof CliAuth.PendingError ? error.status : 400
+      return Response.json({ error: (error as Error).message }, { status })
+    }
+  })
+
+  router.post(`${path}/code`, async (c) => {
+    try {
+      const request = z.decode(CliAuth.createRequest, await c.req.raw.json())
+      const chainId = request.chainId ?? chains[0]!.id
+      getClient(chainId)
+      const result = await CliAuth.createDeviceCode({
+        chainId,
+        ...(now ? { now } : {}),
+        ...(policy ? { policy } : {}),
+        ...(random ? { random } : {}),
+        request,
+        store,
+        ...(typeof ttlMs !== 'undefined' ? { ttlMs } : {}),
+      })
+
+      return Response.json(z.encode(CliAuth.createResponse, result))
+    } catch (error) {
+      return Response.json({ error: (error as Error).message }, { status: 400 })
+    }
+  })
+
+  router.post(`${path}/poll/:code`, async (c) => {
+    try {
+      const request = z.decode(CliAuth.pollRequest, await c.req.raw.json())
+      const code = c.req.param('code')
+      const result = await CliAuth.poll({
+        code,
+        ...(now ? { now } : {}),
+        request,
+        store,
+      })
+
+      return Response.json(z.encode(CliAuth.pollResponse, result))
+    } catch (error) {
+      return Response.json({ error: (error as Error).message }, { status: 400 })
+    }
+  })
+
+  router.post(path, async (c) => {
+    try {
+      const request = z.decode(CliAuth.authorizeRequest, await c.req.raw.json())
+      const result = await CliAuth.authorize({
+        client: getClient(request.keyAuthorization.chainId),
+        ...(now ? { now } : {}),
+        request,
+        store,
+      })
+
+      return Response.json(z.encode(CliAuth.authorizeResponse, result))
+    } catch (error) {
+      return Response.json({ error: (error as Error).message }, { status: 400 })
+    }
+  })
+
+  return router
+}
+
+export declare namespace codeAuth {
+  export type Options = from.Options & {
+    /**
+     * Supported chains. The handler resolves the client based on chain IDs carried
+     * by device-code requests and key authorizations.
+     * @default [tempo, tempoModerato]
+     */
+    chains?: readonly [Chain, ...Chain[]] | undefined
+    /** Time source used for TTL evaluation. */
+    now?: (() => number) | undefined
+    /** Path prefix for the code auth endpoints. @default "/auth/pkce" */
+    path?: string | undefined
+    /** Policy used to validate and default requested CLI auth fields. */
+    policy?: CliAuth.Policy | undefined
+    /** Random byte generator used for device-code allocation. */
+    random?: ((size: number) => Uint8Array) | undefined
+    /** Device-code store. */
+    store?: CliAuth.Store | undefined
+    /** Transports keyed by chain ID. Defaults to `http()` for each chain. */
+    transports?: Record<number, Transport> | undefined
+    /** Pending entry TTL in milliseconds. @default 600000 */
+    ttlMs?: number | undefined
+  }
+}

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

@@ -0,0 +1,335 @@
+import type { RpcRequest } from 'ox'
+import { SignatureEnvelope, Transaction as core_Transaction, TxEnvelopeTempo } from 'ox/tempo'
+import { parseUnits } from 'viem'
+import { sendTransactionSync } 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 receipt = await sendTransactionSync(client, {
+      feePayer: true,
+      to: '0x0000000000000000000000000000000000000000',
+    })
+
+    expect(receipt.feePayer).toBe(feePayerAccount.address.toLowerCase())
+
+    expect(requests.map(({ method }) => method)).toMatchInlineSnapshot(`
+      [
+        "eth_sendRawTransactionSync",
+      ]
+    `)
+  })
+
+  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: '0x0000000000000000000000000000000000000000',
+    })
+
+    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()
+  })
+})