mppx 0.11.0 → 0.13.1

package/dist/tempo/internal/fee-payer.js

@@ -1,10 +1,13 @@
-import { Secp256k1 } from 'ox';
-import { TxEnvelopeTempo } from 'ox/tempo';
-import { decodeFunctionData, encodeFunctionData, maxUint256, toHex } from 'viem';
+import { Address, Secp256k1 } from 'ox';
+import { TempoAddress, TxEnvelopeTempo } from 'ox/tempo';
+import { decodeFunctionData, encodeFunctionData, maxUint256, toFunctionSelector, toHex } from 'viem';
 import { Abis, Addresses, Transaction } from 'viem/tempo';
+import { escrowAbi as legacyEscrowAbi } from '../legacy/session/escrow.abi.js';
+import { escrowAbi } from '../session/precompile/escrow.abi.js';
 import * as TempoAddress_internal from './address.js';
 import * as defaults from './defaults.js';
 import { defaultFeeTokens } from './fee-token.js';
+import { machineTokenSwapperAbi } from './machine-token-charge.js';
 import * as Selectors from './selectors.js';
 /** Returns true if the serialized transaction has a Tempo envelope prefix. */
 export function isTempoTransaction(serialized) {
@@ -63,15 +66,17 @@ const supportedTransactionKeys = new Set([
 export function defaultAllowedFeeTokens(chainId) {
     return defaultFeeTokens(chainId);
 }
-/** Rejects a sponsored fee token outside the server's allowlist. */
+/** Validates the fee-token address and, when supplied, the server's allowlist. */
 export function assertAllowedFeeToken(transaction, allowedFeeTokens) {
     const { feeToken } = transaction;
     if (feeToken === undefined)
         return;
-    if (typeof feeToken !== 'string')
+    if (typeof feeToken !== 'string' ||
+        !(Address.validate(feeToken, { strict: false }) || TempoAddress.validate(feeToken)))
         throw new FeePayerValidationError('fee-sponsored transaction feeToken is invalid', {});
     const normalized = feeToken;
-    if (!allowedFeeTokens.some((allowed) => TempoAddress_internal.isEqual(allowed, normalized)))
+    if (allowedFeeTokens &&
+        !allowedFeeTokens.some((allowed) => TempoAddress_internal.isEqual(allowed, normalized)))
         throw new FeePayerValidationError('fee-sponsored transaction feeToken is not allowed', {
             feeToken,
         });
@@ -230,7 +235,7 @@ export async function preflightSponsorship(parameters) {
  * swap transactions at peak gas prices. Bumped from 0.01 ETH in #327.
  */
 const defaultPolicy = {
-    allowKeyAuthorization: true,
+    allowKeyAuthorization: false,
     maxGas: 2000000n,
     maxFeePerGas: 100000000000n,
     maxPriorityFeePerGas: 10000000000n,
@@ -261,16 +266,26 @@ function getPolicy(chainId, overrides) {
 function isExpiringNonceKey(nonceKey) {
     return nonceKey === 'expiring' || nonceKey === maxUint256;
 }
-const sponsoredCallAbi = [...Abis.tip20, ...Abis.stablecoinDex];
+const sponsoredCallAbi = [
+    ...Abis.tip20,
+    ...Abis.stablecoinDex,
+    ...machineTokenSwapperAbi,
+    ...legacyEscrowAbi,
+    ...escrowAbi,
+];
 const sponsoredCallSelectors = new Set([
     Selectors.approve,
     Selectors.transfer,
     Selectors.transferWithMemo,
     Selectors.swapExactAmountOut,
+    ...machineTokenSwapperAbi.map((item) => toFunctionSelector(item)),
+    ...[...legacyEscrowAbi, ...escrowAbi]
+        .filter((item) => item.type === 'function' && item.stateMutability === 'nonpayable')
+        .map((item) => toFunctionSelector(item)),
 ]);
 function canonicalSponsoredCallData(data, call, fail) {
     if (!sponsoredCallSelectors.has(data.slice(0, 10)))
-        return undefined;
+        fail('fee-sponsored transaction call calldata is invalid', { call });
     let decoded;
     try {
         decoded = decodeFunctionData({ abi: sponsoredCallAbi, data });
@@ -310,13 +325,16 @@ function assertCanonicalSponsoredTransaction(transaction, fail) {
                 call: callIndex,
             });
         const canonical = canonicalSponsoredCallData(data, callIndex, fail);
-        if (canonical && data.toLowerCase() !== canonical.toLowerCase())
+        if (data.toLowerCase() !== canonical.toLowerCase())
             fail('fee-sponsored transaction call calldata is not canonical', {
                 call: callIndex,
             });
     }
 }
-/** Validates that a set of transaction calls matches an allowed fee-payer pattern. */
+/**
+ * Validates an allowed fee-payer pattern. Returns the funding currency when the
+ * calls are bound to the expected payment transfers.
+ */
 export function validateCalls(calls, details, options) {
     if (calls.length === 0)
         throw new FeePayerValidationError('disallowed call pattern in fee-payer transaction', details);
@@ -416,6 +434,7 @@ export function validateCalls(calls, details, options) {
             throw new FeePayerValidationError('payment transfer does not match challenge', details);
         used.add(matchIndex);
     }
+    return approveCall?.to ?? currency;
 }
 /** Validates sponsor fee policy limits for a fee-payer transaction. */
 export function assertTransactionPolicy(parameters) {

package/dist/tempo/internal/machine-token-charge.d.ts

@@ -1,5 +1,28 @@
 import type * as Hex from 'ox/Hex';
 import { type Address, type Client } from 'viem';
+/** ABI for the first-party machine-token settlement swapper. */
+export declare const machineTokenSwapperAbi: readonly [{
+    readonly name: "swapTo";
+    readonly type: 'function';
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "inputToken";
+    }, {
+        readonly type: "uint256";
+        readonly name: "amount";
+    }, {
+        readonly type: "address";
+        readonly name: "targetToken";
+    }, {
+        readonly type: "address";
+        readonly name: "recipient";
+    }, {
+        readonly type: "bytes32";
+        readonly name: "memo";
+    }];
+    readonly outputs: readonly [];
+}];
 type Call = {
     data?: Hex.Hex | undefined;
     to?: Address | undefined;

package/dist/tempo/internal/machine-token-charge.js

@@ -2,7 +2,8 @@ import { decodeFunctionData, encodeFunctionData, isAddress, isAddressEqual, pars
 import { call, readContract } from 'viem/actions';
 import { Abis, Actions } from 'viem/tempo';
 import * as defaults from './defaults.js';
-const machineTokenSwapperAbi = parseAbi([
+/** ABI for the first-party machine-token settlement swapper. */
+export const machineTokenSwapperAbi = parseAbi([
     'function swapTo(address inputToken,uint256 amount,address targetToken,address recipient,bytes32 memo)',
 ]);
 function getDeployment(chainId) {

package/dist/tempo/legacy/index.d.ts

@@ -1,5 +1,3 @@
-/** Legacy contract-backed session client surface. */
-export * as Client from './client/index.js';
-/** Legacy contract-backed session channel primitives used by the client. */
+/** Legacy contract-backed session channel primitives retained for compatibility. */
 export * as Session from './session/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/tempo/legacy/index.js

@@ -1,5 +1,3 @@
-/** Legacy contract-backed session client surface. */
-export * as Client from './client/index.js';
-/** Legacy contract-backed session channel primitives used by the client. */
+/** Legacy contract-backed session channel primitives retained for compatibility. */
 export * as Session from './session/index.js';
 //# sourceMappingURL=index.js.map

package/dist/tempo/server/Charge.d.ts

@@ -45,6 +45,16 @@ export declare namespace charge {
         } | undefined;
     };
     type Parameters = {
+        /**
+         * Tokens permitted for sponsored charge transaction fees, including tokens
+         * selected by a remote fee payer. Local sponsorship defaults to pathUSD and
+         * USDC.e on mainnet, and pathUSD on other chains. Hosted sponsorship has no
+         * token allowlist by default and trusts the configured provider's choice.
+         * A custom list replaces the local defaults and restricts hosted sponsorship.
+         * It must contain at least one token. Address validation and other sponsorship
+         * checks still apply. This does not change the payment currency or sessions.
+         */
+        allowedFeeTokens?: readonly `0x${string}`[] | undefined;
         /** Enables first-party machine-token funding through the canonical swapper. */
         machineTokenEnabled?: boolean | undefined;
         /** Render payment page when Accept header is text/html (e.g. in browsers) */
@@ -58,7 +68,8 @@ export declare namespace charge {
         feePayerPolicy?: FeePayerPolicy | undefined;
         /**
          * Token a local fee payer uses to pay gas. If omitted, mppx selects a
-         * funded allowed token, preferring pathUSD.
+         * funded allowed token in `allowedFeeTokens` order (pathUSD first by default).
+         * An explicit token must also be in the allowed list.
          *
          * This option is not supported with a remote fee-payer URL, which selects
          * its own token.

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';
@@ -33,7 +33,9 @@ import * as SponsorBudget from './SponsorBudget.js';
  * ```
  */
 export function charge(parameters = {}) {
-    const { machineTokenEnabled, amount, currency = defaults.resolveCurrency(parameters), decimals = defaults.decimals, description, externalId, feeToken: configuredFeeToken, feePayerPolicy, html, relay, sponsorBudget, splits, supportedModes, validateSender, waitForConfirmation = true, } = parameters;
+    const { machineTokenEnabled, allowedFeeTokens: configuredAllowedFeeTokens, amount, currency = defaults.resolveCurrency(parameters), decimals = defaults.decimals, description, externalId, feeToken: configuredFeeToken, feePayerPolicy, html, relay, sponsorBudget, splits, supportedModes, validateSender, waitForConfirmation = true, } = parameters;
+    if (configuredAllowedFeeTokens?.length === 0)
+        throw new Error('`allowedFeeTokens` must contain at least one token.');
     const storeKeyPrefix = parameters.storeKeyPrefix ?? '';
     const rawStore = (parameters.store ?? Store.memory());
     const store = Store.from(rawStore, { keyPrefix: storeKeyPrefix });
@@ -92,7 +94,12 @@ export function charge(parameters = {}) {
         Expires.assert(challenge.expires, challenge.id);
         if (isZeroAmount && payload.type !== 'proof')
             throw new MismatchError('Zero-amount challenges require a proof credential.', {});
+        // Request-level local sponsorship takes precedence over the hosted provider.
+        const localFeePayer = Account.is(request.feePayer) ? request.feePayer : feePayer;
+        const allowedFeeTokens = configuredAllowedFeeTokens ??
+            (localFeePayer || !remoteFeePayer ? FeePayer.defaultAllowedFeeTokens(chainId) : undefined);
         return {
+            allowedFeeTokens,
             amount,
             machineTokenEnabled,
             chainId,
@@ -109,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'))
@@ -134,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;
@@ -174,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;
@@ -183,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, FeePayer.defaultAllowedFeeTokens(chainId));
+            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,
         };
@@ -237,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',
@@ -245,6 +279,7 @@ export function charge(parameters = {}) {
                         serializedTransaction,
                         transfers,
                     },
+                    fundingCurrency,
                     isFeePayerTx,
                     serializedTransaction,
                     settlementSenders,
@@ -305,6 +340,8 @@ export function charge(parameters = {}) {
             const chainId = await (async () => {
                 if (request.chainId)
                     return request.chainId;
+                if (parameters.chainId !== undefined)
+                    return parameters.chainId;
                 if (parameters.testnet)
                     return defaults.chainId.testnet;
                 return (await getClient({})).chain?.id;
@@ -374,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))) {
@@ -382,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))) {
@@ -402,12 +446,10 @@ export function charge(parameters = {}) {
                     let finalHash;
                     let reservation;
                     try {
-                        const allowedFeeTokens = FeePayer.defaultAllowedFeeTokens(chainId);
-                        if (isFeePayerTx)
-                            FeePayer.assertAllowedFeeToken(transaction, allowedFeeTokens);
-                        const selectableFeeTokens = allowedFeeTokens;
+                        const { allowedFeeTokens } = context;
                         const completedTransaction = await (async () => {
                             if (feePayerAccount && methodDetails?.feePayer !== false) {
+                                const selectableFeeTokens = allowedFeeTokens ?? FeePayer.defaultAllowedFeeTokens(chainId);
                                 const completed = await FeePayer.preflightSponsorship({
                                     transaction,
                                     simulate: (request) => viem_call(client, request),
@@ -422,7 +464,7 @@ export function charge(parameters = {}) {
                                             }));
                                         const sponsored = FeePayer.prepareSponsoredTransaction({
                                             account: feePayerAccount,
-                                            allowedFeeTokens,
+                                            allowedFeeTokens: selectableFeeTokens,
                                             challengeExpires: expires,
                                             chainId: chainId ?? client.chain.id,
                                             details: { amount, currency, recipient },
@@ -534,7 +576,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
@@ -551,12 +593,7 @@ 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) {
@@ -687,6 +724,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 = [];
@@ -889,46 +928,38 @@ 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,
     };
 }
-/**
- * Asserts that at least one of the matched payment logs carries a
- * challenge-bound memo nonce (keccak256(challengeId)[0..6] in bytes 25–31).
- * Only checks logs that were matched by `assertTransferLogs`, not the
- * entire receipt — preventing unrelated dust transfers from satisfying
- * the binding.
- * @internal
- */
 function assertChallengeBoundMemo(matchedLogs, parameters) {
-    const bound = matchedLogs.some((log) => {
-        if (log.kind !== 'memo')
-            return false;
-        if (!Attribution.verifyServer(log.args.memo, parameters.realm))
-            return false;
-        return Attribution.verifyChallengeBinding(log.args.memo, parameters.challengeId);
-    });
-    if (!bound)
-        throw new MismatchError('Payment verification failed: memo is not bound to this challenge.', {});
+    assertChallengeBoundMemos(matchedLogs.map((log) => (log.kind === 'memo' ? log.args.memo : undefined)), parameters);
 }
 function assertChallengeBoundCallMemo(matchedCalls, parameters) {
-    const bound = matchedCalls.some((call) => {
-        if (!call.memo)
-            return false;
-        const memo = call.memo;
-        if (!Attribution.verifyServer(memo, parameters.realm))
-            return false;
-        return Attribution.verifyChallengeBinding(memo, parameters.challengeId);
-    });
+    assertChallengeBoundMemos(matchedCalls.map((call) => call.memo), parameters);
+}
+/**
+ * Requires a challenge-bound attribution memo and rejects conflicting attribution
+ * on matched payment transfers. Otherwise, a split payment could authorize another
+ * challenge after the first challenge's replay marker expires. Unmatched transfers
+ * cannot establish the binding; plain transfers and non-MPP memos remain allowed.
+ * @internal
+ */
+function assertChallengeBoundMemos(memos, parameters) {
+    let bound = false;
+    for (const memo of memos) {
+        if (!memo || !Attribution.isMppMemo(memo))
+            continue;
+        if (!Attribution.verifyServer(memo, parameters.realm) ||
+            !Attribution.verifyChallengeBinding(memo, parameters.challengeId))
+            throw new MismatchError('Payment verification failed: memo is not bound to this challenge.', {});
+        bound = true;
+    }
     if (!bound)
         throw new MismatchError('Payment verification failed: memo is not bound to this challenge.', {});
 }