mppx 0.8.13 → 0.8.15

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

@@ -47,6 +47,17 @@ function testAccount() {
   return privateKeyToAccount(generatePrivateKey())
 }
 
+function sponsoredFeeExposure(credential: string) {
+  const payload = Credential.deserialize<{ signature: string; type: string }>(credential).payload
+  if (payload.type !== 'transaction') throw new Error('expected transaction credential')
+  const transaction = Transaction.deserialize(
+    payload.signature as Parameters<typeof Transaction.deserialize>[0],
+  )
+  if (transaction.gas === undefined || transaction.maxFeePerGas === undefined)
+    throw new Error('expected sponsored transaction fee fields')
+  return transaction.gas * transaction.maxFeePerGas
+}
+
 // TODO: Remove once the minimum viem version is >=2.54.0, which uses client-first Tempo call builders.
 function tokenTransferCall(parameters: viem_token.transfer.Args) {
   const call = Actions.token.transfer.call as unknown as {
@@ -376,17 +387,10 @@ describe('tempo', () => {
       expect(await dedupStore.get(`tenant:mppx:charge:${receipt.transactionHash}`)).not.toBeNull()
       expect(await dedupStore.get(`mppx:charge:${receipt.transactionHash}`)).toBeNull()
 
-      const response2 = await fetch(httpServer.url)
-      expect(response2.status).toBe(402)
-
-      const challenge2 = Challenge.fromResponse(response2, {
-        methods: [tempo_client.charge()],
-      })
-
       const mixedCaseHash = `0x${receipt.transactionHash.slice(2).toUpperCase()}` as Hex.Hex
 
       const credential2 = Credential.from({
-        challenge: challenge2,
+        challenge: challenge1,
         payload: { hash: mixedCaseHash, type: 'hash' as const },
       })
 
@@ -462,15 +466,8 @@ describe('tempo', () => {
       }
 
       // Replay with lowercase — should be rejected
-      const response2 = await fetch(httpServer.url)
-      expect(response2.status).toBe(402)
-
-      const challenge2 = Challenge.fromResponse(response2, {
-        methods: [tempo_client.charge()],
-      })
-
       const credential2 = Credential.from({
-        challenge: challenge2,
+        challenge: challenge1,
         payload: { hash: receipt.transactionHash.toLowerCase() as Hex.Hex, type: 'hash' as const },
       })
 
@@ -702,17 +699,10 @@ describe('tempo', () => {
         expect(response.status).toBe(200)
       }
 
-      const response2 = await fetch(httpServer.url)
-      expect(response2.status).toBe(402)
-
-      const challenge2 = Challenge.fromResponse(response2, {
-        methods: [tempo_client.charge()],
-      })
-
       const mixedCaseHash = `0x${receipt.transactionHash.slice(2).toUpperCase()}` as Hex.Hex
 
       const credential2 = Credential.from({
-        challenge: challenge2,
+        challenge: challenge1,
         payload: { hash: mixedCaseHash, type: 'hash' as const },
       })
 
@@ -786,15 +776,8 @@ describe('tempo', () => {
         expect(response.status).toBe(200)
       }
 
-      const response2 = await fetch(httpServer.url)
-      expect(response2.status).toBe(402)
-
-      const challenge2 = Challenge.fromResponse(response2, {
-        methods: [tempo_client.charge()],
-      })
-
       const credential2 = Credential.from({
-        challenge: challenge2,
+        challenge: challenge1,
         payload: { hash: receipt.transactionHash.toLowerCase() as Hex.Hex, type: 'hash' as const },
       })
 
@@ -1131,16 +1114,10 @@ describe('tempo', () => {
       expect(pullAuthResponse.status).toBe(200)
 
       const pullReceipt = Receipt.fromResponse(pullAuthResponse)
-
-      const replayChallengeResponse = await fetch(httpServer.url)
-      expect(replayChallengeResponse.status).toBe(402)
-
-      const replayChallenge = Challenge.fromResponse(replayChallengeResponse, {
-        methods: [tempo_client.charge()],
-      })
+      const pullCredential = Credential.deserialize(pullCredentialSerialized)
 
       const replayCredential = Credential.from({
-        challenge: replayChallenge,
+        challenge: pullCredential.challenge,
         payload: { hash: pullReceipt.reference as Hex.Hex, type: 'hash' as const },
       })
 
@@ -1546,6 +1523,62 @@ describe('tempo', () => {
       httpServer.close()
     })
 
+    test('behavior: validates fee-payer pull credential before settlement', async () => {
+      const chargeServer = Mppx_server.create({
+        methods: [
+          tempo_server.charge({
+            getClient() {
+              return client
+            },
+            currency: asset,
+            account: accounts[0],
+            feePayer: accounts[0],
+            store: Store.memory(),
+          }),
+        ],
+        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(
+          chargeServer.charge({
+            amount: '1',
+            currency: asset,
+            recipient: accounts[0].address,
+          }),
+        )(req, res)
+        if (result.status === 402) return
+        res.end('OK')
+      })
+
+      const response = await fetch(httpServer.url)
+      expect(response.status).toBe(402)
+
+      const credential = await mppx.createCredential(response)
+      const validation = await chargeServer.validateCredential(credential)
+
+      expect(validation.details).toMatchObject({
+        mode: 'pull',
+        sender: accounts[1].address.toLowerCase(),
+      })
+
+      const receipt = await chargeServer.verifyCredential(credential)
+      expect(receipt.status).toBe('success')
+      httpServer.close()
+    })
+
     test('behavior: fee payer simulates before broadcasting in confirmation mode', async () => {
       const rpcMethods: string[] = []
       const interceptingClient = createClient({
@@ -1917,26 +1950,26 @@ describe('tempo', () => {
       httpServer.close()
     })
 
-    test('behavior: fee payer rejects concurrent in-flight transactions from one sender', async () => {
-      let releaseSimulation!: () => void
-      let resolveSimulationStarted!: () => void
-      const simulationStarted = new Promise<void>((resolve) => {
-        resolveSimulationStarted = resolve
+    test('behavior: fee payer allows concurrent expiring-nonce transactions from one sender', async () => {
+      let releaseBroadcast!: () => void
+      let resolveBroadcastStarted!: () => void
+      const broadcastStarted = new Promise<void>((resolve) => {
+        resolveBroadcastStarted = resolve
       })
-      const releaseSimulationPromise = new Promise<void>((resolve) => {
-        releaseSimulation = resolve
+      const releaseBroadcastPromise = new Promise<void>((resolve) => {
+        releaseBroadcast = resolve
       })
-      let heldFirstSimulation = false
+      let heldFirstBroadcast = false
 
       const interceptingClient = createClient({
         account: accounts[0],
         chain: client.chain,
         transport: custom({
           async request(args: any) {
-            if (args.method === 'eth_call' && !heldFirstSimulation) {
-              heldFirstSimulation = true
-              resolveSimulationStarted()
-              await releaseSimulationPromise
+            if (args.method === 'eth_sendRawTransactionSync' && !heldFirstBroadcast) {
+              heldFirstBroadcast = true
+              resolveBroadcastStarted()
+              await releaseBroadcastPromise
             }
             return client.transport.request(args)
           },
@@ -1998,30 +2031,206 @@ describe('tempo', () => {
       ])
 
       const first = fetch(httpServer.url, { headers: { Authorization: credential1 } })
-      await simulationStarted
-      expect(
-        await sponsoredStore.get(
-          `tenant:mppx:charge:sponsor:${chain.id}:${accounts[1].address.toLowerCase()}`,
-        ),
-      ).not.toBeNull()
+      await broadcastStarted
+      const sponsorBudgetKey =
+        `mppx:charge:sponsor-budget:${chain.id}:${accounts[0].address.toLowerCase()}` as const
+      expect(await sponsoredStore.get(sponsorBudgetKey)).not.toBeNull()
       expect(
         await sponsoredStore.get(
-          `mppx:charge:sponsor:${chain.id}:${accounts[1].address.toLowerCase()}`,
+          `tenant:mppx:charge:sponsor-budget:${chain.id}:${accounts[0].address.toLowerCase()}`,
         ),
       ).toBeNull()
       const second = fetch(httpServer.url, { headers: { Authorization: credential2 } })
 
       try {
         const secondResponse = await second
-        expect(secondResponse.status).toBe(402)
-        const body = (await secondResponse.json()) as { detail: string }
-        expect(body.detail).toContain('Sponsored transaction from this sender is already in flight')
+        expect(secondResponse.status).toBe(200)
       } finally {
-        releaseSimulation()
+        releaseBroadcast()
       }
 
       const firstResponse = await first
       expect(firstResponse.status).toBe(200)
+      expect(await sponsoredStore.get(sponsorBudgetKey)).toBeNull()
+
+      httpServer.close()
+    })
+
+    test('behavior: fee payer waits for atomic sponsor budget capacity', async () => {
+      let releaseBroadcast!: () => void
+      let resolveBroadcastStarted!: () => void
+      const broadcastStarted = new Promise<void>((resolve) => {
+        resolveBroadcastStarted = resolve
+      })
+      const releaseBroadcastPromise = new Promise<void>((resolve) => {
+        releaseBroadcast = resolve
+      })
+      let heldFirstBroadcast = false
+
+      const interceptingClient = createClient({
+        account: accounts[0],
+        chain: client.chain,
+        transport: custom({
+          async request(args: any) {
+            if (args.method === 'eth_sendRawTransactionSync' && !heldFirstBroadcast) {
+              heldFirstBroadcast = true
+              resolveBroadcastStarted()
+              await releaseBroadcastPromise
+            }
+            return client.transport.request(args)
+          },
+        }),
+      })
+
+      const feePayerPolicy: { maxInFlightTotalFee?: bigint } = {}
+      const sponsoredStore = Store.memory()
+      const serverWithBudget = Mppx_server.create({
+        methods: [
+          tempo_server.charge({
+            feePayerPolicy,
+            getClient() {
+              return interceptingClient
+            },
+            currency: asset,
+            account: accounts[0],
+            store: sponsoredStore,
+          }),
+        ],
+        realm,
+        secretKey,
+      })
+
+      const mppx1 = Mppx_client.create({
+        polyfill: false,
+        methods: [
+          tempo_client({
+            account: accounts[1],
+            getClient() {
+              return client
+            },
+          }),
+        ],
+      })
+      const mppx2 = Mppx_client.create({
+        polyfill: false,
+        methods: [
+          tempo_client({
+            account: accounts[2],
+            getClient() {
+              return client
+            },
+          }),
+        ],
+      })
+
+      const httpServer = await Http.createServer(async (req, res) => {
+        const result = await Mppx_server.toNodeListener(
+          serverWithBudget.charge({
+            feePayer: accounts[0],
+            amount: '1',
+            currency: asset,
+            recipient: accounts[0].address,
+          }),
+        )(req, res)
+        if (result.status === 402) return
+        res.end('OK')
+      })
+
+      const [challengeResponse1, challengeResponse2] = await Promise.all([
+        fetch(httpServer.url),
+        fetch(httpServer.url),
+      ])
+      const [credential1, credential2] = await Promise.all([
+        mppx1.createCredential(challengeResponse1),
+        mppx2.createCredential(challengeResponse2),
+      ])
+      feePayerPolicy.maxInFlightTotalFee = [
+        sponsoredFeeExposure(credential1),
+        sponsoredFeeExposure(credential2),
+      ].reduce((maximum, exposure) => (exposure > maximum ? exposure : maximum))
+
+      const first = fetch(httpServer.url, { headers: { Authorization: credential1 } })
+      await broadcastStarted
+      const second = fetch(httpServer.url, { headers: { Authorization: credential2 } })
+      try {
+        const secondBeforeRelease = await Promise.race([
+          second.then(() => 'settled' as const),
+          new Promise<'waiting'>((resolve) => setTimeout(() => resolve('waiting'), 50)),
+        ])
+        expect(secondBeforeRelease).toBe('waiting')
+      } finally {
+        releaseBroadcast()
+      }
+      const [firstResponse, secondResponse] = await Promise.all([first, second])
+      expect(firstResponse.status).toBe(200)
+      expect(secondResponse.status).toBe(200)
+      expect(
+        await sponsoredStore.get(
+          `mppx:charge:sponsor-budget:${chain.id}:${accounts[0].address.toLowerCase()}`,
+        ),
+      ).toBeNull()
+
+      httpServer.close()
+    })
+
+    test('behavior: fee payer reclaims expired sponsor budget reservations', async () => {
+      const sponsoredStore = Store.memory()
+      const sponsorBudgetKey =
+        `mppx:charge:sponsor-budget:${chain.id}:${accounts[0].address.toLowerCase()}` as const
+      await sponsoredStore.put(sponsorBudgetKey, {
+        reservations: {
+          stale: {
+            expiresAt: Date.now() - 1,
+            fee: '500000000000000000',
+            leaseUntil: Date.now() - 1,
+            owner: 'stale-worker',
+            phase: 'pending',
+            transactionHash: `0x${'01'.repeat(32)}`,
+          },
+        },
+        version: 1,
+      })
+      const serverWithStaleBudget = Mppx_server.create({
+        methods: [
+          tempo_server.charge({
+            getClient() {
+              return client
+            },
+            currency: asset,
+            account: accounts[0],
+            store: sponsoredStore,
+          }),
+        ],
+        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(
+          serverWithStaleBudget.charge({
+            feePayer: accounts[0],
+            amount: '1',
+            currency: asset,
+            recipient: accounts[0].address,
+          }),
+        )(req, res)
+        if (result.status === 402) return
+        res.end('OK')
+      })
+
+      const response = await mppx.fetch(httpServer.url)
+      expect(response.status).toBe(200)
+      expect(await sponsoredStore.get(sponsorBudgetKey)).toBeNull()
 
       httpServer.close()
     })
@@ -2782,6 +2991,71 @@ describe('tempo', () => {
 
       httpServer.close()
     })
+
+    test('retains sponsored exposure until receipt reconciliation', async () => {
+      const sponsoredStore = Store.memory()
+      const serverNoWait = Mppx_server.create({
+        methods: [
+          tempo_server.charge({
+            getClient() {
+              return client
+            },
+            currency: asset,
+            account: accounts[0],
+            store: sponsoredStore,
+            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)
+      const response = await fetch(httpServer.url, {
+        headers: { Authorization: credential },
+      })
+
+      expect(response.status).toBe(200)
+      const receipt = Receipt.fromResponse(response)
+      const sponsorBudgetKey =
+        `mppx:charge:sponsor-budget:${chain.id}:${accounts[0].address.toLowerCase()}` as const
+      expect(await sponsoredStore.get(sponsorBudgetKey)).toMatchObject({
+        reservations: {
+          [receipt.reference]: {
+            owner: expect.any(String),
+            phase: 'pending',
+            transactionHash: receipt.reference,
+          },
+        },
+        version: 1,
+      })
+
+      httpServer.close()
+    })
   })
 
   describe('intent: charge; type: proof (zero-dollar auth)', () => {