chore(tempo): keep split payment PR narrowly scoped

brendanjryan · brendanjryan · commit 49263cb49d41 · 2026-03-27T10:42:12.000-07:00
diff --git a/src/tempo/client/Charge.ts b/src/tempo/client/Charge.ts
@@ -1,6 +1,6 @@
 import type * as Hex from 'ox/Hex'
 import type { Address } from 'viem'
-import { prepareTransactionRequest, sendTransactionSync, signTransaction } from 'viem/actions'
+import { prepareTransactionRequest, sendCallsSync, signTransaction } from 'viem/actions'
 import { tempo as tempo_chain } from 'viem/chains'
 import { Actions } from 'viem/tempo'
 
@@ -112,17 +112,16 @@ export function charge(parameters: charge.Parameters = {}) {
       })()
 
       if (mode === 'push') {
-        if (methodDetails?.feePayer)
-          throw new Error('`feePayer: true` requires pull mode so the server can co-sign it.')
-
-        const receipt = await sendTransactionSync(client, {
+        const { receipts } = await sendCallsSync(client, {
           account,
-          calls,
-          validBefore,
-        } as never)
+          calls: calls as never,
+          experimental_fallback: true,
+        })
+        const hash = receipts?.[0]?.transactionHash
+        if (!hash) throw new Error('No transaction receipt returned.')
         return Credential.serialize({
           challenge,
-          payload: { hash: receipt.transactionHash, type: 'hash' },
+          payload: { hash, type: 'hash' },
           source: `did:pkh:eip155:${chainId}:${account.address}`,
         })
       }
diff --git a/src/tempo/server/Charge.test.ts b/src/tempo/server/Charge.test.ts
@@ -5,12 +5,7 @@ import type { Hex } from 'ox'
 import { TxEnvelopeTempo } from 'ox/tempo'
 import { Handler } from 'tempo.ts/server'
 import { createClient, custom, encodeFunctionData, parseUnits } from 'viem'
-import {
-  getTransaction,
-  getTransactionReceipt,
-  prepareTransactionRequest,
-  signTransaction,
-} from 'viem/actions'
+import { getTransactionReceipt, prepareTransactionRequest, signTransaction } from 'viem/actions'
 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'
@@ -118,161 +113,6 @@ describe('tempo', () => {
       httpServer.close()
     })
 
-    test('behavior: push mode sets validBefore no later than challenge expiry', async () => {
-      const expires = new Date(Date.now() + 60_000).toISOString()
-      const mppx = Mppx_client.create({
-        polyfill: false,
-        methods: [
-          tempo_client({
-            account: accounts[1],
-            mode: 'push',
-            getClient: () => client,
-          }),
-        ],
-      })
-
-      const httpServer = await Http.createServer(async (req, res) => {
-        const result = await Mppx_server.toNodeListener(
-          server.charge({
-            amount: '1',
-            currency: asset,
-            expires,
-            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)
-
-      const receipt = Receipt.fromResponse(response)
-      const transaction = await getTransaction(client, {
-        hash: receipt.reference as Hex.Hex,
-      })
-
-      expect(transaction.validBefore).toBeTypeOf('number')
-      expect(transaction.validBefore!).toBeLessThanOrEqual(
-        Math.floor(new Date(expires).getTime() / 1000),
-      )
-
-      httpServer.close()
-    })
-
-    test('behavior: rejects hash credentials for fee-payer challenges', async () => {
-      const httpServer = await Http.createServer(async (req, res) => {
-        const result = await Mppx_server.toNodeListener(
-          server.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 fetch(httpServer.url)
-      expect(response.status).toBe(402)
-
-      const challenge = Challenge.fromResponse(response, {
-        methods: [tempo_client.charge()],
-      })
-
-      const { receipt } = await Actions.token.transferSync(client, {
-        account: accounts[1],
-        amount: BigInt(challenge.request.amount),
-        to: challenge.request.recipient as Hex.Hex,
-        token: challenge.request.currency as Hex.Hex,
-      })
-
-      const credential = Credential.from({
-        challenge,
-        payload: { hash: receipt.transactionHash, type: 'hash' as const },
-        source: `did:pkh:eip155:${chain.id}:${accounts[1].address}`,
-      })
-
-      const authResponse = await fetch(httpServer.url, {
-        headers: { Authorization: Credential.serialize(credential) },
-      })
-      expect(authResponse.status).toBe(402)
-
-      const body = (await authResponse.json()) as { detail: string }
-      expect(body.detail).toContain('Hash credentials cannot be used when `feePayer` is true.')
-
-      httpServer.close()
-    })
-
-    test('behavior: verifies payment effects even when receipt.from differs', async () => {
-      const interceptingClient = createClient({
-        chain: client.chain,
-        transport: custom({
-          async request(args: any) {
-            const result = await client.transport.request(args)
-            if (args?.method === 'eth_getTransactionReceipt') {
-              return {
-                ...(result as any),
-                from: accounts[0].address,
-              }
-            }
-            return result
-          },
-        }),
-      })
-
-      const serverProxy = Mppx_server.create({
-        methods: [
-          tempo_server.charge({
-            getClient() {
-              return interceptingClient
-            },
-            currency: asset,
-            account: accounts[0],
-          }),
-        ],
-        realm,
-        secretKey,
-      })
-
-      const httpServer = await Http.createServer(async (req, res) => {
-        const result = await Mppx_server.toNodeListener(serverProxy.charge({ amount: '1' }))(
-          req,
-          res,
-        )
-        if (result.status === 402) return
-        res.end('OK')
-      })
-
-      const response = await fetch(httpServer.url)
-      expect(response.status).toBe(402)
-
-      const challenge = Challenge.fromResponse(response, {
-        methods: [tempo_client.charge()],
-      })
-
-      const { receipt } = await Actions.token.transferSync(client, {
-        account: accounts[1],
-        amount: BigInt(challenge.request.amount),
-        to: challenge.request.recipient as Hex.Hex,
-        token: challenge.request.currency as Hex.Hex,
-      })
-
-      const credential = Credential.from({
-        challenge,
-        payload: { hash: receipt.transactionHash, type: 'hash' as const },
-        source: `did:pkh:eip155:${chain.id}:${accounts[1].address}`,
-      })
-
-      const authResponse = await fetch(httpServer.url, {
-        headers: { Authorization: Credential.serialize(credential) },
-      })
-      expect(authResponse.status).toBe(200)
-
-      httpServer.close()
-    })
-
     test('behavior: rejects replayed transaction hash', async () => {
       const dedupServer = Mppx_server.create({
         methods: [
@@ -1417,43 +1257,6 @@ describe('tempo', () => {
       httpServer.close()
     })
 
-    test('error: rejects push mode for fee-payer challenges', async () => {
-      const mppx = Mppx_client.create({
-        polyfill: false,
-        methods: [
-          tempo_client({
-            account: accounts[1],
-            mode: 'push',
-            getClient() {
-              return client
-            },
-          }),
-        ],
-      })
-
-      const httpServer = await Http.createServer(async (req, res) => {
-        const result = await Mppx_server.toNodeListener(
-          server.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 fetch(httpServer.url)
-      expect(response.status).toBe(402)
-
-      await expect(mppx.createCredential(response)).rejects.toThrow(
-        '`feePayer: true` requires pull mode so the server can co-sign it.',
-      )
-
-      httpServer.close()
-    })
-
     test('behavior: fee payer with splits', async () => {
       const mppx = Mppx_client.create({
         polyfill: false,
diff --git a/src/tempo/server/Charge.ts b/src/tempo/server/Charge.ts
@@ -103,7 +103,7 @@ export function charge<const parameters extends charge.Parameters>(
     },
 
     async verify({ credential, request }) {
-      const { challenge, source } = credential
+      const { challenge } = credential
       const { chainId, feePayer } = request
 
       const client = await getClient({ chainId })
@@ -123,17 +123,14 @@ export function charge<const parameters extends charge.Parameters>(
 
       switch (payload.type) {
         case 'hash': {
-          if (methodDetails?.feePayer)
-            throw new MismatchError('Hash credentials cannot be used when `feePayer` is true.', {})
-
           const hash = payload.hash as `0x${string}`
           await assertHashUnused(store, hash)
 
           const expectedTransfers = getExpectedTransfers({ amount, memo, methodDetails, recipient })
           const receipt = await getTransactionReceipt(client, { hash })
           assertTransferLogs(receipt, {
             currency,
-            sender: getCredentialSourceAddress(source) ?? receipt.from,
+            sender: receipt.from,
             transfers: expectedTransfers,
           })
 
@@ -192,6 +189,7 @@ export function charge<const parameters extends charge.Parameters>(
             })
             assertTransferLogs(receipt, {
               currency,
+              sender: transaction.from! as `0x${string}`,
               transfers,
             })
             // Post-broadcast dedup: catch malleable input variants
@@ -407,7 +405,7 @@ function assertTransferLogs(
   receipt: TransactionReceipt,
   parameters: {
     currency: `0x${string}`
-    sender?: `0x${string}` | undefined
+    sender: `0x${string}`
     transfers: readonly ExpectedTransfer[]
   },
 ) {
@@ -438,7 +436,7 @@ function assertTransferLogs(
     const matchIndex = logs.findIndex((log, index) => {
       if (used.has(index)) return false
       if (!TempoAddress.isEqual(log.address, parameters.currency)) return false
-      if (parameters.sender && !TempoAddress.isEqual(log.args.from, parameters.sender)) return false
+      if (!TempoAddress.isEqual(log.args.from, parameters.sender)) return false
       if (!TempoAddress.isEqual(log.args.to, transfer.recipient)) return false
       if (log.args.amount.toString() !== transfer.amount) return false
       if (transfer.memo) {
@@ -460,11 +458,6 @@ function assertTransferLogs(
   }
 }
 
-function getCredentialSourceAddress(source: string | undefined): `0x${string}` | undefined {
-  const match = source?.match(/^did:pkh:eip155:\d+:(0x[0-9a-fA-F]{40})$/)
-  return match?.[1] as `0x${string}` | undefined
-}
-
 /** @internal */
 function getHashStoreKey(hash: `0x${string}`): `mppx:charge:${string}` {
   return `mppx:charge:${hash.toLowerCase()}`
