mppx 0.17.0 → 0.17.3

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

@@ -1,4 +1,4 @@
-import { Address, Secp256k1 } from 'ox';
+import { Address, Secp256k1, Signature } from 'ox';
 import { TempoAddress, TxEnvelopeTempo } from 'ox/tempo';
 import { decodeFunctionData, encodeFunctionData, maxUint256, toFunctionSelector, toHex } from 'viem';
 import { Abis, Addresses, Transaction } from 'viem/tempo';
@@ -163,6 +163,12 @@ export async function fillHostedFeePayerTransaction(parameters) {
     })();
     return {
         feePayer,
+        // `Signature.fromRpc` rejects a yParity of 0 that arrives without `v`.
+        feePayerSignature: Signature.from({
+            r: BigInt(feePayerSignature.r),
+            s: BigInt(feePayerSignature.s),
+            yParity: feePayerSignature.yParity,
+        }),
         feeToken,
         serializedTransaction: await Transaction.serialize({
             ...transaction,
@@ -175,17 +181,36 @@ export async function fillHostedFeePayerTransaction(parameters) {
 /**
  * Returns a transaction shape suitable for pre-broadcast simulation.
  *
- * Sponsored transactions are first simulated as calls from the sender with no
- * fee fields or signatures. This checks call execution without requiring the
- * sender to hold the fee token; transferred value and call-level balances are
- * still checked by the RPC.
+ * Sponsored transactions are first simulated as calls from the sender, without
+ * signatures, fee payer or fee token, and with zero fee fields: Tempo nodes
+ * (v1.18+) skip the fee-token balance check for a zero-fee `eth_call`, so the
+ * sender's fee balance is irrelevant. The call keeps the transaction's exact
+ * gas limit and the fields that set its intrinsic gas (nonce, nonce key,
+ * validity window, key authorization, signature type), so it is the gas-bounded
+ * check at the broadcast limit: a transaction whose gas is too low fails here
+ * with out of gas instead of reverting onchain at the sponsor's expense.
+ * Transferred value and call-level balances are still checked by the RPC.
  */
 export function simulationTransaction(transaction, options) {
-    if (options.feePayer)
+    if (options.feePayer) {
+        const keyType = senderKeyType(transaction.signature);
         return {
             account: transaction.from,
             calls: transaction.calls,
+            ...(transaction.accessList?.length ? { accessList: transaction.accessList } : {}),
+            ...(transaction.gas !== undefined ? { gas: transaction.gas } : {}),
+            ...(transaction.keyAuthorization !== undefined
+                ? { keyAuthorization: transaction.keyAuthorization }
+                : {}),
+            ...(keyType ? { keyType } : {}),
+            maxFeePerGas: 0n,
+            maxPriorityFeePerGas: 0n,
+            ...(transaction.nonce !== undefined ? { nonce: transaction.nonce } : {}),
+            ...(transaction.nonceKey !== undefined ? { nonceKey: transaction.nonceKey } : {}),
+            ...(transaction.validAfter !== undefined ? { validAfter: transaction.validAfter } : {}),
+            ...(transaction.validBefore !== undefined ? { validBefore: transaction.validBefore } : {}),
         };
+    }
     return {
         ...transaction,
         account: transaction.from,
@@ -193,43 +218,182 @@ export function simulationTransaction(transaction, options) {
         feePayerSignature: undefined,
     };
 }
+/** The key type hint for a sender signature whose verification costs more than secp256k1. */
+function senderKeyType(signature) {
+    const envelope = signature;
+    const type = envelope?.type === 'keychain' ? envelope.inner?.type : envelope?.type;
+    return type === 'p256' || type === 'webAuthn' ? type : undefined;
+}
 /**
  * Returns the final fee-sponsored transaction shape for pre-broadcast
- * simulation. RPC `eth_call` does not carry either transaction signature.
+ * simulation.
+ *
+ * Tempo nodes recover the fee payer of an `eth_call` only from
+ * `feePayerSignature`; a bare `feePayer` address is ignored and the sender is
+ * billed instead. Pass the sponsor's signature so the node charges the fee
+ * token to the sponsor, not to a sender that may not hold it. The sender's own
+ * signature is never sent.
  */
 export function sponsoredSimulationTransaction(transaction, options) {
-    const { feePayer, feeToken } = options;
+    const { feePayer, feePayerSignature, feeToken } = options;
     return {
         ...transaction,
         account: transaction.from,
         calls: transaction.calls,
         feePayer,
-        feePayerSignature: undefined,
+        feePayerSignature: feePayerSignature ? Signature.toRpc(feePayerSignature) : undefined,
         ...(feeToken !== undefined ? { feeToken } : {}),
         signature: undefined,
     };
 }
 /**
- * Runs execution-only sender and final-envelope simulations around sponsorship.
+ * Signs the fee-payer payload of a sponsored envelope with a local fee-payer
+ * account, the same payload `Transaction.serialize` signs before broadcast.
+ * Returns `undefined` when the envelope's fee payer cannot sign locally.
+ */
+export async function signFeePayerSimulation(transaction) {
+    const { account: _account, feePayer, ...rest } = transaction;
+    if (typeof feePayer !== 'object' || feePayer === null)
+        return undefined;
+    const sign = feePayer.sign;
+    if (typeof sign !== 'function' || !rest.from)
+        return undefined;
+    const payload = TxEnvelopeTempo.getFeePayerSignPayload(TxEnvelopeTempo.from({
+        ...rest,
+        chainId: Number(rest.chainId),
+        feePayerSignature: undefined,
+        signature: undefined,
+        type: 'tempo',
+    }), { sender: rest.from });
+    return Signature.from(await sign({ hash: payload }));
+}
+/**
+ * Runs the sender and final-envelope simulations around sponsorship.
+ *
+ * First, it simulates the sender's calls at the transaction's exact gas limit
+ * with zero fee fields (see {@link simulationTransaction}). This is the
+ * gas-bounded check at the broadcast limit, and needs no fee-token balance.
+ * Next, `complete` resolves the sponsor and produces the co-signed transaction.
+ * Finally, it simulates that transaction with its concrete fee payer, fee token
+ * and fee payer signature, so the node bills the sponsor rather than the sender
+ * and checks the sponsor's fee balance.
  *
- * First, it simulates the calls with the sender as `from`, omitting fee fields
- * and signatures so the sender's fee balance is irrelevant. Next, `complete`
- * resolves the sponsor and produces the co-signed transaction. Finally, it
- * simulates that transaction with its concrete fee payer and fee token.
+ * A sponsored `eth_call` charges more gas than the mined transaction uses. A
+ * local fee payer therefore signs a simulation-only copy whose gas is raised by
+ * up to {@link sponsoredSimulationGasBuffer}, clamped so the copy stays within
+ * the same fee payer `policy` (`maxGas`, `maxTotalFee`) as the real
+ * transaction. The copy is never returned or broadcast. When the final
+ * simulation runs without the full buffer (hosted signatures cover the client's
+ * gas and cannot be padded, or the padding was clamped), a failure that is only
+ * out of gas is tolerated, since the sender simulation already bounded gas at
+ * the broadcast limit. Every other failure, such as an insufficient fee balance
+ * or a revert, is rethrown.
  *
  * `complete` runs only after sender-context execution succeeds, so a reverting
  * transaction never reaches a local signer or hosted fee-payer.
  */
 export async function preflightSponsorship(parameters) {
-    const { complete, simulate, transaction } = parameters;
+    const { complete, policy, simulate, transaction } = parameters;
     await simulate(simulationTransaction(transaction, { feePayer: true }));
     const completed = await complete();
-    await simulate(sponsoredSimulationTransaction(completed.transaction, {
-        feePayer: completed.feePayer,
-        feeToken: completed.feeToken,
-    }));
+    const { gas } = completed.transaction;
+    const simulated = await (async () => {
+        if (completed.feePayerSignature)
+            return { feePayerSignature: completed.feePayerSignature, transaction: completed.transaction };
+        // The signature binds the gas limit, so a local fee payer signs a simulation-only copy
+        // with headroom for the node's sponsored `eth_call` overhead. The broadcast keeps its gas.
+        const padded = gas === undefined
+            ? completed.transaction
+            : {
+                ...completed.transaction,
+                gas: sponsoredSimulationGas(completed.transaction, policy),
+            };
+        const feePayerSignature = await signFeePayerSimulation(padded);
+        return feePayerSignature
+            ? { feePayerSignature, transaction: padded }
+            : { feePayerSignature: undefined, transaction: completed.transaction };
+    })();
+    const simulatedGas = simulated.transaction.gas;
+    try {
+        await simulate(sponsoredSimulationTransaction(simulated.transaction, {
+            feePayer: completed.feePayer,
+            feePayerSignature: simulated.feePayerSignature,
+            feeToken: completed.feeToken,
+        }));
+    }
+    catch (error) {
+        const unpadded = gas !== undefined &&
+            simulatedGas !== undefined &&
+            simulatedGas < gas + sponsoredSimulationGasBuffer;
+        if (!unpadded || !isOutOfGasError(error))
+            throw error;
+    }
     return completed;
 }
+/**
+ * Returns the gas limit of a local fee payer's simulation-only copy: the
+ * transaction's gas plus {@link sponsoredSimulationGasBuffer}, clamped to the
+ * fee payer policy's `maxGas` and to `maxTotalFee / maxFeePerGas`, so the
+ * signed copy never exceeds a cap the real transaction is held to.
+ */
+export function sponsoredSimulationGas(transaction, policyOverrides) {
+    const { chainId, gas, maxFeePerGas } = transaction;
+    if (gas === undefined)
+        throw new FeePayerValidationError('fee-sponsored transaction must declare gas', {});
+    const policy = getPolicy(Number(chainId), policyOverrides);
+    let cap = policy.maxGas;
+    if (maxFeePerGas !== undefined && maxFeePerGas > 0n) {
+        const feeCap = policy.maxTotalFee / maxFeePerGas;
+        if (feeCap < cap)
+            cap = feeCap;
+    }
+    if (gas > cap)
+        throw new FeePayerValidationError('fee-sponsored transaction gas exceeds sponsor policy', {
+            gas: gas.toString(),
+        });
+    const padded = gas + sponsoredSimulationGasBuffer;
+    return padded < cap ? padded : cap;
+}
+/**
+ * Returns true when a simulation failed only because it ran out of gas.
+ *
+ * Tempo nodes report out of gas as `out of gas: …` (code -32003, shared with
+ * `insufficient fee token balance`) or `intrinsic gas too low` (code -32000),
+ * so this reads the node's own message rather than the code. Only the terminal
+ * RPC failure counts: the deepest `details` in the cause chain (viem's
+ * `RpcRequestError` carries the node's message there), or the deepest message
+ * when no error has details. Wrapper messages are ignored, the match is anchored
+ * to the start of the node's message, and an error carrying revert data is never
+ * treated as gas exhaustion, so a revert reason or wrapper text that merely
+ * mentions gas cannot hide another failure.
+ */
+export function isOutOfGasError(error) {
+    let terminal;
+    let fallback;
+    for (let current = error, depth = 0; current && depth < 10; depth++) {
+        const { cause, data, details, message } = current;
+        if (typeof data === 'string' && data !== '0x')
+            return false;
+        if (typeof details === 'string')
+            terminal = details;
+        if (typeof message === 'string')
+            fallback = message;
+        current = cause;
+    }
+    const nodeMessage = (terminal ?? fallback)?.trim();
+    if (!nodeMessage)
+        return false;
+    return /^(?:out of gas(?::|$)|intrinsic gas too low(?::|$))/i.test(nodeMessage);
+}
+/**
+ * Extra gas a local fee payer signs into its simulation-only envelope. Tempo's sponsored
+ * `eth_call` charges more gas than the same transaction uses when mined (about 6,000 for a
+ * session top-up on v1.18.1), so simulating at the signed limit would reject transactions
+ * that succeed onchain. The padding is clamped to the fee payer policy; hosted signatures
+ * cover the client's gas and are simulated as signed. In both cases the gas bound at the
+ * broadcast limit comes from the sender simulation.
+ */
+export const sponsoredSimulationGasBuffer = 10000n;
 /**
  * maxTotalFee must be high enough to cover `transferWithMemo` and
  * swap transactions at peak gas prices. Bumped from 0.01 ETH in #327.

package/dist/tempo/legacy/session/Chain.js

@@ -355,6 +355,7 @@ export async function broadcastOpenTransaction(parameters) {
                     reason: 'transaction does not contain a valid escrow open call',
                 });
             const completed = await FeePayer.preflightSponsorship({
+                policy: feePayerPolicy,
                 transaction,
                 simulate: (request) => call(client, request),
                 async complete() {
@@ -470,6 +471,7 @@ export async function broadcastTopUpTransaction(parameters) {
                 });
             const defaultFeeToken = defaults.currency[client.chain?.id];
             const completed = await FeePayer.preflightSponsorship({
+                policy: feePayerPolicy,
                 transaction,
                 simulate: (request) => call(client, request),
                 async complete() {

package/dist/tempo/server/Charge.js

@@ -20,7 +20,6 @@ import * as Proof from '../internal/proof.js';
 import * as Selectors from '../internal/selectors.js';
 import * as Methods from '../Methods.js';
 import { fallbackStore } from './internal/fallback-store.js';
-import { html as htmlContent } from './internal/html.gen.js';
 import * as Relay from './Relay.js';
 import * as SponsorBudget from './SponsorBudget.js';
 /**
@@ -322,7 +321,7 @@ export function charge(parameters = {}) {
         html: html
             ? {
                 config: {},
-                content: htmlContent,
+                content: async () => (await import('./internal/html.gen.js')).html,
                 formatAmount: async (request) => {
                     try {
                         const chainId = request.methodDetails?.chainId;
@@ -481,6 +480,7 @@ export function charge(parameters = {}) {
                             if (feePayerAccount && methodDetails?.feePayer !== false) {
                                 const selectableFeeTokens = allowedFeeTokens ?? FeePayer.defaultAllowedFeeTokens(chainId);
                                 const completed = await FeePayer.preflightSponsorship({
+                                    policy: transactionFeePayerPolicy,
                                     transaction,
                                     simulate: (request) => viem_call(client, request),
                                     async complete() {
@@ -1042,6 +1042,8 @@ const ambiguousErrorNames = new Set([
  * - JSON-RPC code `4`: the EIP-7966 timeout for a pooled, unconfirmed transaction.
  * - Messages containing the words "already known" or "known transaction": already
  *   pooled ("unknown transaction type" does not match).
+ * - Tempo's `ExpiringNonceReplay`: an expiring-nonce transaction with this hash was
+ *   already accepted, such as when a transport retries a send the node took.
  */
 function isAmbiguousBroadcastError(error) {
     for (let cause = error; cause; cause = cause.cause) {
@@ -1054,7 +1056,8 @@ function isAmbiguousBroadcastError(error) {
             return true;
         if (code === 4)
             return true;
-        if (typeof message === 'string' && /\balready ?known\b|\bknown transaction\b/i.test(message))
+        if (typeof message === 'string' &&
+            /\balready ?known\b|\bknown transaction\b|\bExpiringNonceReplay\b/i.test(message))
             return true;
     }
     return false;

package/dist/tempo/server/Subscription.js

@@ -713,6 +713,7 @@ async function submitSubscriptionPayment(parameters) {
         const userSerialized = await signTransaction(client, prepared);
         const userTransaction = Transaction.deserialize(userSerialized);
         const completed = await FeePayer.preflightSponsorship({
+            policy: feePayerPolicy,
             transaction: userTransaction,
             simulate: (request) => viem_call(client, request),
             async complete() {