accounts 0.6.1 → 0.6.2

package/src/server/Handler.test.ts

@@ -1,17 +1,10 @@
 import { Elysia } from 'elysia'
 import express from 'express'
 import { Hono } from 'hono'
-import { Json, type RpcRequest } from 'ox'
-import { SignatureEnvelope, Transaction as core_Transaction, TxEnvelopeTempo } from 'ox/tempo'
-import { sendTransactionSync } from 'viem/actions'
-import { Transaction, withFeePayer } from 'viem/tempo'
-import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vp/test'
-
-import { accounts, chain, getClient, http } from '../../test/config.js'
-import { createServer, type Server } from '../../test/utils.js'
-import * as WebAuthnCeremony from '../core/WebAuthnCeremony.js'
+import { describe, expect, test } from 'vp/test'
+
+import { createServer } from '../../test/utils.js'
 import * as Handler from './Handler.js'
-import * as Kv from './Kv.js'
 
 describe('from', () => {
   describe('cors', () => {
@@ -696,411 +689,3 @@ describe('from', () => {
     })
   })
 })
-
-describe('feePayer', () => {
-  const userAccount = accounts[9]!
-  const feePayerAccount = accounts[0]!
-
-  let server: Server
-  let requests: RpcRequest.RpcRequest[] = []
-
-  beforeAll(async () => {
-    server = await createServer(
-      Handler.feePayer({
-        account: feePayerAccount,
-        chains: [chain],
-        transports: { [chain.id]: http() },
-        onRequest: async (request) => {
-          requests.push(request)
-        },
-      }).listener,
-    )
-  })
-
-  afterAll(() => {
-    server.close()
-    process.on('SIGINT', () => {
-      server.close()
-      process.exit(0)
-    })
-    process.on('SIGTERM', () => {
-      server.close()
-      process.exit(0)
-    })
-  })
-
-  afterEach(() => {
-    requests = []
-  })
-
-  async function rpc(request: Record<string, unknown>) {
-    return await fetch(server.url, {
-      body: Json.stringify(request),
-      headers: { 'content-type': 'application/json' },
-      method: 'POST',
-    }).then((response) => response.json())
-  }
-
-  /** 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 rpc({
-        id: 1,
-        jsonrpc: '2.0',
-        method: 'eth_fillTransaction',
-        params: [
-          {
-            chainId: chain.id,
-            feePayer: true,
-            from: userAccount.address,
-            to: '0x0000000000000000000000000000000000000000',
-          },
-        ],
-      })) as {
-        result: {
-          sponsor: { address: string }
-          tx: Record<string, unknown>
-        }
-      }
-      const prepared = core_Transaction.fromRpc(response.result.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.result.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 rpc({
-        id: 1,
-        jsonrpc: '2.0',
-        method: 'eth_fillTransaction',
-        params: [
-          {
-            chainId: chain.id,
-            feePayer: true,
-            from: userAccount.address,
-            to: '0x0000000000000000000000000000000000000000',
-          },
-        ],
-      })) as {
-        result: { tx: Record<string, unknown> }
-      }
-      const prepared = core_Transaction.fromRpc(response.result.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(
-        fetch(server.url, {
-          method: 'POST',
-          body: JSON.stringify({
-            jsonrpc: '2.0',
-            id: 1,
-            method: 'eth_chainId',
-          }),
-        }).then((response) => response.json()),
-      ).resolves.toMatchInlineSnapshot(`
-        {
-          "error": {
-            "code": -32004,
-            "name": "RpcResponse.MethodNotSupportedError",
-            "stack": "",
-          },
-          "id": 1,
-          "jsonrpc": "2.0",
-        }
-      `)
-    })
-
-    test('behavior: internal error', async () => {
-      const response = await fetch(server.url, {
-        method: 'POST',
-        body: JSON.stringify({
-          jsonrpc: '2.0',
-          id: 1,
-          method: 'eth_signRawTransaction',
-          params: ['0xinvalid'],
-        }),
-      })
-
-      const data = await response.json()
-      expect(data).toMatchInlineSnapshot(`
-        {
-          "error": {
-            "code": -32602,
-            "name": "RpcResponse.InvalidParamsError",
-            "stack": "",
-          },
-          "id": 1,
-          "jsonrpc": "2.0",
-        }
-      `)
-    })
-  })
-})
-
-describe('webauthn', () => {
-  let server: Server
-  let ceremony: WebAuthnCeremony.WebAuthnCeremony
-
-  beforeAll(async () => {
-    server = await createServer(
-      Handler.webAuthn({
-        kv: Kv.memory(),
-        origin: 'http://localhost',
-        rpId: 'localhost',
-      }).listener,
-    )
-    ceremony = WebAuthnCeremony.server({ url: server.url })
-  })
-
-  afterAll(async () => {
-    await server.closeAsync()
-  })
-
-  describe('POST /register/options', () => {
-    test('default: returns registration options', async () => {
-      const { options } = await ceremony.getRegistrationOptions({ name: 'Test' })
-      expect(options.publicKey).toBeDefined()
-      expect(options.publicKey!.rp.id).toMatchInlineSnapshot(`"localhost"`)
-      expect(options.publicKey!.rp.name).toMatchInlineSnapshot(`"localhost"`)
-      expect(typeof options.publicKey!.challenge).toMatchInlineSnapshot(`"string"`)
-    })
-
-    test('behavior: each call generates a unique challenge', async () => {
-      const { options: a } = await ceremony.getRegistrationOptions({ name: 'Test' })
-      const { options: b } = await ceremony.getRegistrationOptions({ name: 'Test' })
-      expect(a.publicKey!.challenge).not.toBe(b.publicKey!.challenge)
-    })
-  })
-
-  describe('POST /login/options', () => {
-    test('default: returns authentication options', async () => {
-      const { options } = await ceremony.getAuthenticationOptions()
-      expect(options.publicKey).toBeDefined()
-      expect(options.publicKey!.rpId).toMatchInlineSnapshot(`"localhost"`)
-      expect(typeof options.publicKey!.challenge).toMatchInlineSnapshot(`"string"`)
-    })
-
-    test('behavior: each call generates a unique challenge', async () => {
-      const { options: a } = await ceremony.getAuthenticationOptions()
-      const { options: b } = await ceremony.getAuthenticationOptions()
-      expect(a.publicKey!.challenge).not.toBe(b.publicKey!.challenge)
-    })
-  })
-
-  describe('POST /register', () => {
-    test('error: invalid credential → 400', async () => {
-      const response = await fetch(`${server.url}/register`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ id: 'fake', clientDataJSON: 'bad', attestationObject: 'bad' }),
-      })
-      expect(response.status).toBe(400)
-      const body = await response.json()
-      expect(body.error).toBeTypeOf('string')
-    })
-  })
-
-  describe('POST /login', () => {
-    test('error: unknown credential → 400', async () => {
-      const response = await fetch(`${server.url}/login`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          id: 'unknown',
-          metadata: { authenticatorData: '0x00', clientDataJSON: '{"challenge":"0xdead"}' },
-          raw: {
-            id: 'unknown',
-            type: 'public-key',
-            authenticatorAttachment: null,
-            rawId: 'unknown',
-            response: { clientDataJSON: 'e30' },
-          },
-          signature: '0x00',
-        }),
-      })
-      expect(response.status).toBe(400)
-      const body = await response.json()
-      expect(body.error).toMatchInlineSnapshot(`"Missing or expired challenge"`)
-    })
-  })
-
-  describe('challenge replay', () => {
-    test('behavior: challenge consumed after register/options → re-fetching is required', async () => {
-      // Get options twice — each should have a unique challenge stored in KV
-      const { options: a } = await ceremony.getRegistrationOptions({ name: 'Replay' })
-      const { options: b } = await ceremony.getRegistrationOptions({ name: 'Replay' })
-      expect(a.publicKey!.challenge).not.toBe(b.publicKey!.challenge)
-    })
-
-    test('behavior: challenge consumed after login/options → re-fetching is required', async () => {
-      const { options: a } = await ceremony.getAuthenticationOptions()
-      const { options: b } = await ceremony.getAuthenticationOptions()
-      expect(a.publicKey!.challenge).not.toBe(b.publicKey!.challenge)
-    })
-  })
-
-  describe('hooks', () => {
-    test('behavior: onRegister error does not call hook', async () => {
-      let called = false
-      const hookServer = await createServer(
-        Handler.webAuthn({
-          kv: Kv.memory(),
-          origin: 'http://localhost',
-          rpId: 'localhost',
-          onRegister() {
-            called = true
-            return Response.json({ extra: true })
-          },
-        }).listener,
-      )
-
-      const response = await fetch(`${hookServer.url}/register`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ id: 'fake', clientDataJSON: 'bad', attestationObject: 'bad' }),
-      })
-      expect(response.status).toBe(400)
-      expect(called).toBe(false)
-
-      await hookServer.closeAsync()
-    })
-
-    test('behavior: onAuthenticate error does not call hook', async () => {
-      let called = false
-      const hookServer = await createServer(
-        Handler.webAuthn({
-          kv: Kv.memory(),
-          origin: 'http://localhost',
-          rpId: 'localhost',
-          onAuthenticate() {
-            called = true
-            return Response.json({ extra: true })
-          },
-        }).listener,
-      )
-
-      const response = await fetch(`${hookServer.url}/login`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          id: 'unknown',
-          metadata: { authenticatorData: '0x00', clientDataJSON: '{"challenge":"0xdead"}' },
-          raw: {
-            id: 'unknown',
-            type: 'public-key',
-            authenticatorAttachment: null,
-            rawId: 'unknown',
-            response: { clientDataJSON: 'e30' },
-          },
-          signature: '0x00',
-        }),
-      })
-      expect(response.status).toBe(400)
-      expect(called).toBe(false)
-
-      await hookServer.closeAsync()
-    })
-  })
-})