mppx 0.6.31 → 0.8.0

package/src/tempo/server/Charge.test.ts

@@ -3,8 +3,8 @@ import { Mppx as Mppx_client, tempo as tempo_client } from 'mppx/client'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
 import { P256, type Hex, WebAuthnP256 } from 'ox'
 import { SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
-import { Handler } from 'tempo.ts/server'
-import { createClient, custom, encodeFunctionData, parseUnits } from 'viem'
+import { createClient, custom, encodeFunctionData, parseSignature, parseUnits } from 'viem'
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 import {
   getTransactionReceipt,
   prepareTransactionRequest,
@@ -15,16 +15,36 @@ import {
 import { Abis, Account, Actions, Addresses, Secp256k1, Tick, Transaction } from 'viem/tempo'
 import { beforeAll, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
-import { closeChannelOnChain, deployEscrow, openChannel } from '~test/tempo/session.js'
+import {
+  closeChannelOnChain,
+  deployEscrow,
+  openChannel,
+  signVoucher,
+} from '~test/tempo/legacy/session.js'
 import { accounts, asset, chain, client, fundAccount, http } from '~test/tempo/viem.js'
 
 import * as Store from '../../Store.js'
 import * as Attribution from '../Attribution.js'
+import * as defaults from '../internal/defaults.js'
 import * as Proof from '../internal/proof.js'
-import { signVoucher } from '../session/Voucher.js'
 
 const realm = 'api.example.com'
-const secretKey = 'test-secret-key'
+const secretKey = 'test-secret-key-test-secret-key-32'
+
+function isPairAlreadyExistsError(error: unknown) {
+  if (typeof error !== 'object' || error === null) return false
+  const candidate = error as {
+    details?: string | undefined
+    shortMessage?: string | undefined
+  }
+  return [candidate.details, candidate.shortMessage].some((message) =>
+    message?.includes('PairAlreadyExists'),
+  )
+}
+
+function testAccount() {
+  return privateKeyToAccount(generatePrivateKey())
+}
 
 type ProofAccessKeyContext = {
   accessKey: ReturnType<typeof Account.fromSecp256k1>
@@ -1584,6 +1604,228 @@ describe('tempo', () => {
       httpServer.close()
     })
 
+    test('behavior: fee payer pre-broadcast simulation targets the co-signed transaction', async () => {
+      // The pre-broadcast simulation must reflect the FINAL co-signed envelope
+      // (concrete sponsor fee payer), not the pre-cosign 0x78 (`feePayer: true`).
+      const callRequests: any[] = []
+      const interceptingClient = createClient({
+        account: accounts[0],
+        chain: client.chain,
+        transport: custom({
+          async request(args: any) {
+            if (args.method === 'eth_call') callRequests.push(args.params?.[0])
+            return client.transport.request(args)
+          },
+        }),
+      })
+
+      const serverWithTrace = Mppx_server.create({
+        methods: [
+          tempo_server.charge({
+            getClient() {
+              return interceptingClient
+            },
+            currency: asset,
+            account: accounts[0],
+          }),
+        ],
+        realm,
+        secretKey,
+      })
+
+      const mppx = Mppx_client.create({
+        polyfill: false,
+        methods: [
+          tempo_client({
+            account: accounts[1],
+            getClient() {
+              return client
+            },
+          }),
+        ],
+      })
+
+      const httpServer = await Http.createServer(async (req, res) => {
+        const result = await Mppx_server.toNodeListener(
+          serverWithTrace.charge({
+            feePayer: accounts[0],
+            amount: '1',
+            currency: asset,
+            recipient: accounts[0].address,
+          }),
+        )(req, res)
+        if (result.status === 402) return
+        res.end('OK')
+      })
+
+      const challengeResponse = await fetch(httpServer.url)
+      const credential = await mppx.createCredential(challengeResponse)
+      callRequests.length = 0
+
+      const authResponse = await fetch(httpServer.url, {
+        headers: { Authorization: credential },
+      })
+      expect(authResponse.status).toBe(200)
+
+      expect(callRequests.length).toBeGreaterThan(0)
+      const simRequest = callRequests[0]
+      // The co-signed envelope names a concrete sponsor as fee payer. The
+      // pre-cosign 0x78 instead carries `feePayer: true`; asserting the address
+      // proves we simulate the transaction the sponsor actually broadcasts.
+      expect(simRequest.feePayer).not.toBe(true)
+      expect(typeof simRequest.feePayer).toBe('string')
+      expect((simRequest.feePayer as string).toLowerCase()).toBe(accounts[0].address.toLowerCase())
+      // Execution runs as the sender, not the sponsor.
+      expect((simRequest.from as string).toLowerCase()).toBe(accounts[1].address.toLowerCase())
+      expect(simRequest.calls?.length).toBeGreaterThan(0)
+
+      httpServer.close()
+    })
+
+    test('behavior: fee payer fails closed when pre-broadcast simulation reverts', async () => {
+      // A reverting pre-broadcast simulation must abort before broadcast so the
+      // sponsor never pays gas for a transaction that would revert.
+      const rpcMethods: string[] = []
+      const interceptingClient = createClient({
+        account: accounts[0],
+        chain: client.chain,
+        transport: custom({
+          async request(args: any) {
+            rpcMethods.push(args.method)
+            if (args.method === 'eth_call')
+              throw new Error('execution reverted: simulation fixture')
+            return client.transport.request(args)
+          },
+        }),
+      })
+
+      const serverWithRevert = Mppx_server.create({
+        methods: [
+          tempo_server.charge({
+            getClient() {
+              return interceptingClient
+            },
+            currency: asset,
+            account: accounts[0],
+          }),
+        ],
+        realm,
+        secretKey,
+      })
+
+      const mppx = Mppx_client.create({
+        polyfill: false,
+        methods: [
+          tempo_client({
+            account: accounts[1],
+            getClient() {
+              return client
+            },
+          }),
+        ],
+      })
+
+      const httpServer = await Http.createServer(async (req, res) => {
+        const result = await Mppx_server.toNodeListener(
+          serverWithRevert.charge({
+            feePayer: accounts[0],
+            amount: '1',
+            currency: asset,
+            recipient: accounts[0].address,
+          }),
+        )(req, res)
+        if (result.status === 402) return
+        res.end('OK')
+      })
+
+      const challengeResponse = await fetch(httpServer.url)
+      const credential = await mppx.createCredential(challengeResponse)
+      rpcMethods.length = 0
+
+      const authResponse = await fetch(httpServer.url, {
+        headers: { Authorization: credential },
+      })
+
+      // Fails closed: not successful, and the transaction is never broadcast.
+      expect(authResponse.status).not.toBe(200)
+      expect(rpcMethods).toContain('eth_call')
+      expect(rpcMethods).not.toContain('eth_sendRawTransactionSync')
+      expect(rpcMethods).not.toContain('eth_sendRawTransaction')
+
+      httpServer.close()
+    })
+
+    test('behavior: fee payer fails closed when simulation reverts (optimistic mode)', async () => {
+      const rpcMethods: string[] = []
+      const interceptingClient = createClient({
+        account: accounts[0],
+        chain: client.chain,
+        transport: custom({
+          async request(args: any) {
+            rpcMethods.push(args.method)
+            if (args.method === 'eth_call')
+              throw new Error('execution reverted: simulation fixture')
+            return client.transport.request(args)
+          },
+        }),
+      })
+
+      const serverNoWait = Mppx_server.create({
+        methods: [
+          tempo_server.charge({
+            getClient() {
+              return interceptingClient
+            },
+            currency: asset,
+            account: accounts[0],
+            waitForConfirmation: false,
+          }),
+        ],
+        realm,
+        secretKey,
+      })
+
+      const mppx = Mppx_client.create({
+        polyfill: false,
+        methods: [
+          tempo_client({
+            account: accounts[1],
+            getClient() {
+              return client
+            },
+          }),
+        ],
+      })
+
+      const httpServer = await Http.createServer(async (req, res) => {
+        const result = await Mppx_server.toNodeListener(
+          serverNoWait.charge({
+            feePayer: accounts[0],
+            amount: '1',
+            currency: asset,
+            recipient: accounts[0].address,
+          }),
+        )(req, res)
+        if (result.status === 402) return
+        res.end('OK')
+      })
+
+      const challengeResponse = await fetch(httpServer.url)
+      const credential = await mppx.createCredential(challengeResponse)
+      rpcMethods.length = 0
+
+      const authResponse = await fetch(httpServer.url, {
+        headers: { Authorization: credential },
+      })
+
+      expect(authResponse.status).not.toBe(200)
+      expect(rpcMethods).toContain('eth_call')
+      expect(rpcMethods).not.toContain('eth_sendRawTransaction')
+      expect(rpcMethods).not.toContain('eth_sendRawTransactionSync')
+
+      httpServer.close()
+    })
+
     test('behavior: fee payer rejects concurrent in-flight transactions from one sender', async () => {
       let releaseSimulation!: () => void
       let resolveSimulationStarted!: () => void
@@ -1796,11 +2038,64 @@ describe('tempo', () => {
     })
 
     test('behavior: fee payer URL (withFeePayer transport)', async () => {
-      const feePayerHandler = Handler.feePayer({
-        account: accounts[0],
-        client,
+      const feePayerRequests: any[] = []
+      const feePayerServer = await Http.createServer(async (req, res) => {
+        let requestBody = ''
+        for await (const chunk of req) requestBody += chunk
+        const request = JSON.parse(requestBody)
+        feePayerRequests.push(request)
+
+        const transaction = request.params[0]
+        const quantity = (value: unknown) =>
+          value === undefined ? undefined : BigInt(value as string | number | bigint | boolean)
+        const envelope = TxEnvelopeTempo.from({
+          accessList: transaction.accessList,
+          calls: transaction.calls.map(({ value, ...call }: any) => ({
+            ...call,
+            ...(value && value !== '0x' ? { value: BigInt(value) } : {}),
+          })),
+          chainId: chain.id,
+          feeToken: defaults.tokens.pathUsd,
+          from: transaction.from,
+          ...(quantity(transaction.gas) !== undefined ? { gas: quantity(transaction.gas) } : {}),
+          ...(quantity(transaction.maxFeePerGas) !== undefined
+            ? { maxFeePerGas: quantity(transaction.maxFeePerGas) }
+            : {}),
+          ...(quantity(transaction.maxPriorityFeePerGas) !== undefined
+            ? { maxPriorityFeePerGas: quantity(transaction.maxPriorityFeePerGas) }
+            : {}),
+          ...(quantity(transaction.nonce) !== undefined
+            ? { nonce: quantity(transaction.nonce) }
+            : {}),
+          ...(quantity(transaction.nonceKey) !== undefined
+            ? { nonceKey: quantity(transaction.nonceKey) }
+            : {}),
+          type: 'tempo',
+          ...(transaction.validAfter ? { validAfter: Number(BigInt(transaction.validAfter)) } : {}),
+          ...(transaction.validBefore
+            ? { validBefore: Number(BigInt(transaction.validBefore)) }
+            : {}),
+        })
+        const hash = TxEnvelopeTempo.getFeePayerSignPayload(envelope, {
+          sender: transaction.from,
+        })
+        const { r, s, yParity } = parseSignature(await accounts[0].sign!({ hash }))
+        const feePayerSignature = { r, s, yParity }
+
+        res.setHeader('content-type', 'application/json')
+        res.end(
+          JSON.stringify({
+            id: request.id,
+            jsonrpc: '2.0',
+            result: {
+              tx: {
+                feePayerSignature,
+                feeToken: defaults.tokens.pathUsd,
+              },
+            },
+          }),
+        )
       })
-      const feePayerServer = await Http.createServer(feePayerHandler.listener)
 
       const serverWithFeePayer = Mppx_server.create({
         methods: [
@@ -1838,6 +2133,7 @@ describe('tempo', () => {
 
       const response = await mppx.fetch(httpServer.url)
       expect(response.status).toBe(200)
+      expect(feePayerRequests.map(({ method }) => method)).toEqual(['eth_fillTransaction'])
 
       const receipt = Receipt.fromResponse(response)
       expect(receipt.status).toBe('success')
@@ -2410,7 +2706,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, challenge.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: challenge.realm,
+        }),
       })
 
       const credential = Credential.from({
@@ -2448,7 +2748,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, challenge.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: challenge.realm,
+        }),
       })
 
       const credential = Credential.from({
@@ -2563,7 +2867,11 @@ describe('tempo', () => {
             domain: Proof.domain(chain.id),
             types: Proof.types,
             primaryType: 'Proof',
-            message: Proof.message(challenge.id, challenge.realm),
+            message: Proof.message({
+              account: accounts[1].address,
+              challengeId: challenge.id,
+              realm: challenge.realm,
+            }),
           })
 
           const credential = Credential.from({
@@ -2687,6 +2995,91 @@ describe('tempo', () => {
       },
     )
 
+    test('behavior: rejects access-key proof replayed across a co-authorized account', async () => {
+      // The same access key is authorized by two roots (`payer` and `other`),
+      // so a proof bound to `payer` must not be claimable as `other` even
+      // though `other` independently authorized the key.
+      const payer = accounts[1]
+      const other = accounts[2]
+      const accessKey = Account.fromSecp256k1(Secp256k1.randomPrivateKey(), {
+        access: payer,
+      })
+
+      await fundAccount({ address: other.address, token: asset })
+      await Actions.accessKey.authorizeSync(client, {
+        account: payer,
+        accessKey,
+        feeToken: asset,
+      })
+      await Actions.accessKey.authorizeSync(client, {
+        account: other,
+        accessKey,
+        feeToken: asset,
+      })
+
+      const httpServer = await Http.createServer(async (req, res) => {
+        const result = await Mppx_server.toNodeListener(
+          server.charge({ amount: '0', decimals: 6 }),
+        )(req, res)
+        if (result.status === 402) return
+        res.end('OK')
+      })
+
+      try {
+        const response1 = await fetch(httpServer.url)
+        expect(response1.status).toBe(402)
+
+        const challenge = Challenge.fromResponse(response1, {
+          methods: [tempo_client.charge()],
+        })
+
+        // Access key signs a proof bound to `payer` (the `account` field).
+        const signature = await signTypedData(client, {
+          account: accessKey,
+          domain: Proof.domain(chain.id),
+          types: Proof.types,
+          primaryType: 'Proof',
+          message: Proof.message({
+            account: payer.address,
+            challengeId: challenge.id,
+            realm: challenge.realm,
+          }),
+        })
+
+        // The bound payer accepts the proof.
+        const accepted = await fetch(httpServer.url, {
+          headers: {
+            Authorization: Credential.serialize(
+              Credential.from({
+                challenge,
+                payload: { signature, type: 'proof' as const },
+                source: `did:pkh:eip155:${chain.id}:${payer.address}`,
+              }),
+            ),
+          },
+        })
+        expect(accepted.status).toBe(200)
+
+        // Replaying the same proof as `other` is rejected by the wallet binding.
+        const replay = await fetch(httpServer.url, {
+          headers: {
+            Authorization: Credential.serialize(
+              Credential.from({
+                challenge,
+                payload: { signature, type: 'proof' as const },
+                source: `did:pkh:eip155:${chain.id}:${other.address}`,
+              }),
+            ),
+          },
+        })
+        expect(replay.status).toBe(402)
+        const body = (await replay.json()) as { detail: string }
+        expect(body.detail).toContain('Proof signature does not match source.')
+      } finally {
+        httpServer.close()
+      }
+    })
+
     test('behavior: rejects replayed proof credential when store is configured', async () => {
       const replayStore = Store.memory()
       const server_ = Mppx_server.create({
@@ -2724,7 +3117,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, challenge.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: challenge.realm,
+        }),
       })
 
       const credential = Credential.from({
@@ -2785,7 +3182,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, challenge.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: challenge.realm,
+        }),
       })
 
       const credential = Credential.serialize(
@@ -2859,7 +3260,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, challenge.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: challenge.realm,
+        }),
       })
 
       const credential = Credential.from({
@@ -2922,7 +3327,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge1.id, challenge1.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge1.id,
+          realm: challenge1.realm,
+        }),
       })
 
       const credential1 = Credential.from({
@@ -2953,7 +3362,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge2.id, challenge2.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge2.id,
+          realm: challenge2.realm,
+        }),
       })
 
       const credential2 = Credential.from({
@@ -2990,7 +3403,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, challenge.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: challenge.realm,
+        }),
       })
 
       const credential = Credential.from({
@@ -3026,7 +3443,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, challenge.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: challenge.realm,
+        }),
       })
 
       const credential = Credential.from({
@@ -3125,7 +3546,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, challenge.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: challenge.realm,
+        }),
       })
 
       const credential = Credential.from({
@@ -3163,7 +3588,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, challenge.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: challenge.realm,
+        }),
       })
 
       const credential = Credential.from({
@@ -3202,7 +3631,11 @@ describe('tempo', () => {
         domain: Proof.domain(99999),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, challenge.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: challenge.realm,
+        }),
       })
 
       const credential = Credential.from({
@@ -3238,7 +3671,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, 'evil.example.com'),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: 'evil.example.com',
+        }),
       })
 
       const credential = Credential.from({
@@ -3274,7 +3711,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, challenge.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: challenge.realm,
+        }),
       })
 
       const credential = Credential.from({
@@ -3310,7 +3751,11 @@ describe('tempo', () => {
         domain: Proof.domain(chain.id),
         types: Proof.types,
         primaryType: 'Proof',
-        message: Proof.message(challenge.id, challenge.realm),
+        message: Proof.message({
+          account: accounts[1].address,
+          challengeId: challenge.id,
+          realm: challenge.realm,
+        }),
       })
 
       const credential = Credential.from({
@@ -4931,19 +5376,21 @@ describe('tempo', () => {
 
   describe('auto-swap', () => {
     // Use accounts[3] as payer with pathUsd only (no asset).
-    // Use accounts[4] as payer with zero balance.
     const swapPayer = accounts[3]!
-    const brokePayer = accounts[4]!
 
     beforeAll(async () => {
       // Fund swap payer with pathUsd only
       await fundAccount({ address: swapPayer.address, token: Addresses.pathUsd as Hex.Hex })
 
       // Seed DEX liquidity: create pair, then place a sell order for `asset`.
-      await Actions.dex.createPair(client, {
-        account: accounts[0]!,
-        base: asset,
-      })
+      await Actions.dex
+        .createPair(client, {
+          account: accounts[0]!,
+          base: asset,
+        })
+        .catch((error) => {
+          if (!isPairAlreadyExistsError(error)) throw error
+        })
       await fundAccount({ address: accounts[0]!.address, token: asset })
       await Actions.token.approveSync(client, {
         account: accounts[0]!,
@@ -5171,6 +5618,7 @@ describe('tempo', () => {
     })
 
     test('error: throws when no fallback currency has sufficient balance', async () => {
+      const brokePayer = testAccount()
       const mppx = Mppx_client.create({
         polyfill: false,
         methods: [
@@ -5234,6 +5682,7 @@ describe('tempo', () => {
 
     test('error: throws when tokenIn list has no viable candidates', async () => {
       const bogusToken = '0x0000000000000000000000000000000000099999' as const
+      const brokePayer = testAccount()
 
       const mppx = Mppx_client.create({
         polyfill: false,