mppx 0.7.0 → 0.8.1

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

@@ -29,7 +29,7 @@ import * as defaults from '../internal/defaults.js'
 import * as Proof from '../internal/proof.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
@@ -1604,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
@@ -2484,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({
@@ -2522,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({
@@ -2637,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({
@@ -2761,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({
@@ -2798,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({
@@ -2859,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(
@@ -2933,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({
@@ -2996,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({
@@ -3027,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({
@@ -3064,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({
@@ -3100,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({
@@ -3199,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({
@@ -3237,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({
@@ -3276,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({
@@ -3312,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({
@@ -3348,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({
@@ -3384,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({

package/src/tempo/server/Charge.ts

@@ -2,7 +2,6 @@ import * as SignatureEnvelope from 'ox/tempo/SignatureEnvelope'
 import {
   decodeFunctionData,
   formatUnits,
-  hashTypedData,
   keccak256,
   parseEventLogs,
   type TransactionReceipt,
@@ -292,11 +291,15 @@ export function charge<const parameters extends charge.Parameters>(
           }
 
           const valid = await verifyTypedData(client, {
+            // Bind verification to the claimed payer (`source.address`): the
+            // signer may be the payer itself or an access key authorized for it.
             address: source.address,
-            domain: Proof.domain(resolvedChainId),
-            types: Proof.types,
-            primaryType: 'Proof',
-            message: Proof.message(challenge.id, challenge.realm),
+            ...Proof.typedData({
+              account: source.address,
+              chainId: resolvedChainId,
+              challengeId: challenge.id,
+              realm: challenge.realm,
+            }),
             signature: payload.signature as `0x${string}`,
           })
           if (!valid) {
@@ -403,6 +406,13 @@ export function charge<const parameters extends charge.Parameters>(
             const allowedFeeTokens = FeePayer.defaultAllowedFeeTokens(chainId)
             if (isFeePayerTx) FeePayer.assertAllowedFeeToken(transaction, allowedFeeTokens)
 
+            // Request for the pre-broadcast simulation; for sponsored payments
+            // this is overwritten below with the co-signed shape.
+            let simulationRequest: Record<string, unknown> = FeePayer.simulationTransaction(
+              transaction,
+              { feePayer: isFeePayerTx },
+            )
+
             const serializedTransaction_final = await (async () => {
               if (feePayerAccount && methodDetails?.feePayer !== false) {
                 const sponsored = FeePayer.prepareSponsoredTransaction({
@@ -417,22 +427,47 @@ export function charge<const parameters extends charge.Parameters>(
                     feeToken: transaction.feeToken ?? defaults.tokens.pathUsd,
                   },
                 })
+                // `account` is the sender (eth_call `from`); `feePayer` is the
+                // sponsor that pays gas.
+                simulationRequest = {
+                  ...sponsored,
+                  account: transaction.from,
+                  feePayer: feePayerAccount.address,
+                  feePayerSignature: undefined,
+                  signature: undefined,
+                }
                 return signTransaction(client, sponsored as never)
               }
-              if (feePayerUrl && isFeePayerTx)
-                return FeePayer.fillHostedFeePayerTransaction({
+              if (feePayerUrl && isFeePayerTx) {
+                const hosted = await FeePayer.fillHostedFeePayerTransaction({
                   allowedFeeTokens,
+                  challengeExpires: expires,
+                  chainId: chainId ?? client.chain!.id,
+                  details: { amount, currency, recipient },
+                  policy: feePayerPolicy,
                   transaction,
                   url: feePayerUrl,
                 })
+                // Simulate the co-signed envelope (concrete fee payer + chosen
+                // fee token), mirroring the local-sponsor path.
+                simulationRequest = {
+                  ...transaction,
+                  account: transaction.from,
+                  feePayer: hosted.feePayer,
+                  feePayerSignature: undefined,
+                  feeToken: hosted.feeToken,
+                  signature: undefined,
+                }
+                return hosted.serializedTransaction
+              }
               return serializedTransaction
             })()
 
+            // Pre-broadcast simulation: fail closed before broadcast so the
+            // sponsor never pays gas for a transaction that would revert.
+            await viem_call(client, simulationRequest as never)
+
             if (waitForConfirmation) {
-              await viem_call(
-                client,
-                FeePayer.simulationTransaction(transaction, { feePayer: isFeePayerTx }),
-              )
               const receipt = await sendRawTransactionSync(client, {
                 serializedTransaction: serializedTransaction_final,
               })
@@ -462,13 +497,9 @@ export function charge<const parameters extends charge.Parameters>(
               return toReceipt(receipt)
             }
 
-            // Optimistic path: simulate to catch obvious reverts, then broadcast
-            // without waiting for on-chain confirmation. The returned receipt
-            // assumes success — callers opt into this risk via waitForConfirmation: false.
-            await viem_call(
-              client,
-              FeePayer.simulationTransaction(transaction, { feePayer: isFeePayerTx }),
-            )
+            // Optimistic path: broadcast without waiting for confirmation
+            // (simulation above already ran). The returned receipt assumes
+            // success — callers opt in via waitForConfirmation: false.
             const reference = await sendRawTransaction(client, {
               serializedTransaction: serializedTransaction_final,
             })
@@ -1007,12 +1038,7 @@ function recoverAuthorizedProofSigner(parameters: {
 
   try {
     const envelope = SignatureEnvelope.from(signature)
-    const proofHash = hashTypedData({
-      domain: Proof.domain(chainId),
-      types: Proof.types,
-      primaryType: 'Proof',
-      message: Proof.message(challengeId, realm),
-    })
+    const proofHash = Proof.hash({ account: sourceAddress, chainId, challengeId, realm })
 
     if (envelope.type === 'keychain') {
       if (!TempoAddress.isEqual(envelope.userAddress, sourceAddress)) return null

package/src/tempo/server/Methods.ts

@@ -49,14 +49,14 @@ function createSessionMethod<const parameters extends tempo.Parameters>(
 }
 
 /**
- * Creates both Tempo `charge` and `session` methods from shared parameters.
+ * Creates the common Tempo `charge` and `session` methods from shared parameters.
  *
  * @example
  * ```ts
  * import { Mppx, tempo } from 'mppx/server'
  *
  * const mppx = Mppx.create({
- *   methods: [tempo({ currency: '0x...', recipient: '0x...' })],
+ *   methods: [tempo.common({ currency: '0x...', recipient: '0x...' })],
  * })
  * ```
  */
@@ -69,6 +69,8 @@ export namespace tempo {
 
   /** Creates a Tempo `charge` method for one-time TIP-20 token transfers. */
   export const charge = charge_
+  /** Creates the common Tempo `charge` and `session` methods from shared parameters. */
+  export const common = tempo
   /** Creates a TIP-1034 Tempo `session` method for session-based TIP-20 token payments. */
   export const session = sessionServer
   /** @deprecated Use `tempo.session()` for the TIP-1034 session server method. */