mppx 0.12.0 → 0.13.2

package/dist/tempo/server/Charge.js

@@ -1,6 +1,6 @@
 import * as SignatureEnvelope from 'ox/tempo/SignatureEnvelope';
 import { decodeFunctionData, formatUnits, keccak256, parseEventLogs, } from 'viem';
-import { getTransactionReceipt, sendRawTransaction, sendRawTransactionSync, signTransaction, verifyTypedData, call as viem_call, } from 'viem/actions';
+import { getTransaction, getTransactionReceipt, sendRawTransaction, sendRawTransactionSync, signTransaction, verifyTypedData, call as viem_call, } from 'viem/actions';
 import { Abis, Actions, Transaction } from 'viem/tempo';
 import { tempo as tempo_chain } from 'viem/tempo/chains';
 import { PaymentError, VerificationFailedError } from '../../Errors.js';
@@ -116,6 +116,43 @@ export function charge(parameters = {}) {
             supportedModes,
         };
     }
+    /** Validates a recognized payment route and retains its funding metadata. */
+    function validatePaymentRoute(calls, context, transfers, isFeePayerTx = false) {
+        const { amount, currency, machineTokenEnabled, recipient } = context;
+        const machineRoute = machineTokenEnabled
+            ? MachineTokenCharge.matchRoute({
+                calls,
+                chainId: context.chainId ?? context.client.chain?.id,
+                currency,
+                transfers,
+            })
+            : undefined;
+        const matchedCalls = machineRoute?.transfers ??
+            assertTransferCalls(calls, {
+                currency,
+                exactCount: isFeePayerTx,
+                transfers,
+            });
+        assertChallengeBoundCallMemo(matchedCalls, {
+            challengeId: context.challenge.id,
+            realm: context.challenge.realm,
+        });
+        if (machineRoute)
+            return {
+                settlementSenders: [machineRoute.settlementSender],
+                fundingCurrency: machineRoute.calls[0].to,
+            };
+        try {
+            const fundingCurrency = FeePayer.validateCalls(calls, { amount, currency, recipient }, { currency, expectedTransfers: transfers });
+            return { settlementSenders: [], fundingCurrency };
+        }
+        catch (error) {
+            if (isFeePayerTx)
+                throw error;
+            // Unrecognized routes remain valid for unsponsored payments, without funding metadata.
+            return { settlementSenders: [], fundingCurrency: undefined };
+        }
+    }
     async function validateHashCredential(credential, payload, context) {
         const { amount, chainId, challenge, client, currency, methodDetails, recipient, settlementSenders, supportedModes, } = context;
         if (supportedModes && !supportedModes.includes('push'))
@@ -141,7 +178,7 @@ export function charge(parameters = {}) {
             challengeId: challenge.id,
             realm: challenge.realm,
         });
-        return { receipt: toReceipt(receipt), sender, transfers };
+        return { receipt, sender, transfers };
     }
     async function validateProofCredential(credential, payload, context) {
         const { chainId, challenge, client, isZeroAmount } = context;
@@ -181,7 +218,7 @@ export function charge(parameters = {}) {
         return { sender: source.address };
     }
     async function validateTransactionCredential(credential, payload, request, context) {
-        const { machineTokenEnabled, amount, chainId, challenge, client, currency, methodDetails, recipient, requestAllowsFeePayer, supportedModes, } = context;
+        const { amount, chainId, challenge, client, methodDetails, recipient, requestAllowsFeePayer, supportedModes, } = context;
         if (supportedModes && !supportedModes.includes('pull'))
             throw new MismatchError('Transaction credentials are not supported for this challenge.', {});
         const serializedTransaction = payload.signature;
@@ -190,40 +227,30 @@ export function charge(parameters = {}) {
         const transaction = Transaction.deserialize(serializedTransaction);
         if (!transaction.signature || !transaction.from)
             throw new MismatchError('Transaction must be signed by the sender before fee payer co-signing.', {});
+        if (credential.source) {
+            const source = Proof.parsePkhSource(credential.source);
+            const resolvedChainId = challenge.request.methodDetails?.chainId ?? chainId ?? client.chain?.id;
+            if (!source || source.chainId !== resolvedChainId)
+                throw new MismatchError('Transaction credential source is invalid.', {});
+            if (!TempoAddress.isEqual(source.address, transaction.from))
+                throw new MismatchError('Transaction credential source does not match the sender.', {});
+        }
         const isFeePayerTx = methodDetails?.feePayer === true &&
             requestAllowsFeePayer &&
             !!(Account.is(request.feePayer) ? request.feePayer : feePayer || remoteFeePayer);
         const transfers = getExpectedTransfers({ amount, methodDetails, recipient });
-        const machineTokenRoute = machineTokenEnabled
-            ? MachineTokenCharge.matchRoute({
-                calls: transaction.calls ?? [],
-                chainId: chainId ?? client.chain?.id,
-                currency,
-                transfers,
-            })
-            : undefined;
-        const matchedCalls = machineTokenRoute?.transfers ??
-            assertTransferCalls(transaction.calls ?? [], {
-                currency,
-                exactCount: isFeePayerTx,
-                transfers,
-            });
-        assertChallengeBoundCallMemo(matchedCalls, {
-            challengeId: challenge.id,
-            realm: challenge.realm,
-        });
+        const { settlementSenders, fundingCurrency } = validatePaymentRoute(transaction.calls ?? [], context, transfers, isFeePayerTx);
         if (isFeePayerTx) {
-            if (!machineTokenRoute)
-                FeePayer.validateCalls(transaction.calls, { amount, currency, recipient }, { currency, expectedTransfers: transfers });
             FeePayer.assertAllowedFeeToken(transaction, context.allowedFeeTokens);
         }
         else {
             await viem_call(client, FeePayer.simulationTransaction(transaction, { feePayer: false }));
         }
         return {
+            fundingCurrency,
             isFeePayerTx,
             serializedTransaction,
-            settlementSenders: machineTokenRoute ? [machineTokenRoute.settlementSender] : [],
+            settlementSenders,
             transaction,
             transfers,
         };
@@ -244,7 +271,7 @@ export function charge(parameters = {}) {
                 return { details: { mode: 'proof', sender }, type: 'proof' };
             }
             case 'transaction': {
-                const { isFeePayerTx, serializedTransaction, settlementSenders, transaction, transfers } = await validateTransactionCredential(credential, context.payload, request, context);
+                const { fundingCurrency, isFeePayerTx, serializedTransaction, settlementSenders, transaction, transfers, } = await validateTransactionCredential(credential, context.payload, request, context);
                 return {
                     details: {
                         mode: 'pull',
@@ -252,6 +279,7 @@ export function charge(parameters = {}) {
                         serializedTransaction,
                         transfers,
                     },
+                    fundingCurrency,
                     isFeePayerTx,
                     serializedTransaction,
                     settlementSenders,
@@ -383,7 +411,19 @@ export function charge(parameters = {}) {
                             reason: 'Transaction hash has already been used',
                         });
                     }
-                    return receipt;
+                    // Only final hash receipts need this lookup; validation stays receipt-only.
+                    const transaction = await getTransaction(client, { hash }).catch(() => undefined);
+                    let fundingCurrency;
+                    if (transaction && TempoAddress.isEqual(transaction.from, validated.details.sender)) {
+                        try {
+                            fundingCurrency = validatePaymentRoute(transaction.calls ??
+                                (transaction.to ? [{ to: transaction.to, data: transaction.input }] : []), context, validated.details.transfers).fundingCurrency;
+                        }
+                        catch {
+                            // Unrecognized calls do not invalidate an already verified payment.
+                        }
+                    }
+                    return toReceipt(receipt.transactionHash, fundingCurrency);
                 }
                 case 'proof': {
                     if (proofStore && !(await tryClaimProof(proofStore, challenge.id, replayExpires))) {
@@ -391,15 +431,10 @@ export function charge(parameters = {}) {
                             reason: 'Proof credential has already been used',
                         });
                     }
-                    return {
-                        method: 'tempo',
-                        status: 'success',
-                        timestamp: new Date().toISOString(),
-                        reference: challenge.id,
-                    };
+                    return toReceipt(challenge.id);
                 }
                 case 'transaction': {
-                    const { isFeePayerTx, serializedTransaction, settlementSenders, transaction, transfers } = validated;
+                    const { fundingCurrency, isFeePayerTx, serializedTransaction, settlementSenders, transaction, transfers, } = validated;
                     // Pre-broadcast dedup: catch exact byte-for-byte replays early.
                     const hash = keccak256(serializedTransaction);
                     if (!(await tryClaimHash(store, hash, replayExpires))) {
@@ -409,6 +444,9 @@ export function charge(parameters = {}) {
                     }
                     let broadcastAttempted = false;
                     let finalHash;
+                    // Set only after this request claims the final hash, so cleanup never
+                    // releases a marker that another request holds.
+                    let claimedFinalHash;
                     let reservation;
                     try {
                         const { allowedFeeTokens } = context;
@@ -475,11 +513,13 @@ export function charge(parameters = {}) {
                         // Broadcast the same canonical envelope so replay keys match the node reference.
                         const serializedTransaction_final = await Transaction.serialize(Transaction.deserialize(completedTransaction.serializedTransaction));
                         finalHash = keccak256(serializedTransaction_final);
-                        if (finalHash.toLowerCase() !== hash.toLowerCase() &&
-                            !(await tryClaimHash(store, finalHash, replayExpires)))
-                            throw new VerificationFailedError({
-                                reason: 'Transaction hash has already been used',
-                            });
+                        if (finalHash.toLowerCase() !== hash.toLowerCase()) {
+                            if (!(await tryClaimHash(store, finalHash, replayExpires)))
+                                throw new VerificationFailedError({
+                                    reason: 'Transaction hash has already been used',
+                                });
+                            claimedFinalHash = finalHash;
+                        }
                         if (isFeePayerTx) {
                             const sponsor = completedTransaction.sponsor;
                             if (!sponsor)
@@ -541,7 +581,7 @@ export function charge(parameters = {}) {
                                 throw new VerificationFailedError({
                                     reason: 'Broadcast transaction hash does not match the signed transaction',
                                 });
-                            return toReceipt(receipt);
+                            return toReceipt(receipt.transactionHash, fundingCurrency);
                         }
                         // Optimistic path: broadcast without waiting for confirmation
                         // (simulation above already ran). The returned receipt assumes
@@ -558,19 +598,14 @@ export function charge(parameters = {}) {
                             throw new VerificationFailedError({
                                 reason: 'Sponsor budget reservation ownership was lost after broadcast',
                             });
-                        return {
-                            method: 'tempo',
-                            status: 'success',
-                            timestamp: new Date().toISOString(),
-                            reference,
-                        };
+                        return toReceipt(reference, fundingCurrency);
                     }
                     catch (error) {
                         if (!broadcastAttempted) {
                             if (reservation)
                                 await SponsorBudget.release(sponsorBudgetStore, reservation);
-                            if (finalHash && finalHash.toLowerCase() !== hash.toLowerCase())
-                                await releaseHashUse(store, finalHash);
+                            if (claimedFinalHash)
+                                await releaseHashUse(store, claimedFinalHash);
                             await releaseHashUse(store, hash);
                         }
                         throw error;
@@ -694,6 +729,8 @@ function decodeTransferCall(call, currency) {
     return null;
 }
 async function assertTransferLogs(receipt, parameters) {
+    if (receipt.status !== 'success')
+        throw new Error(`Transaction reverted: ${receipt.transactionHash}`);
     const logs = getTransferLogEffects(receipt);
     const used = new Set();
     const matched = [];
@@ -896,16 +933,13 @@ async function isActiveAccessKey(client, parameters) {
     }
 }
 /** @internal */
-function toReceipt(receipt) {
-    const { status, transactionHash } = receipt;
-    if (status !== 'success') {
-        throw new Error(`Transaction reverted: ${transactionHash}`);
-    }
+function toReceipt(reference, fundingCurrency) {
     return {
+        ...(fundingCurrency ? { fundingCurrency } : {}),
         method: 'tempo',
         status: 'success',
         timestamp: new Date().toISOString(),
-        reference: transactionHash,
+        reference,
     };
 }
 function assertChallengeBoundMemo(matchedLogs, parameters) {