mppx 0.11.0 → 0.13.1

package/dist/tempo/session/server/Ws.js

@@ -3,7 +3,7 @@ import * as Credential from '../../../Credential.js';
 import { createSessionReceipt, deserializeSessionReceipt, formatApplicationMessage, formatCloseReadyMessage, formatErrorMessage, formatNeedVoucherMessage, formatReceiptMessage, parseMessage, readSessionChallengeAmount, requireSessionCredentialContext, } from '../precompile/Protocol.js';
 import * as ChannelStore from './ChannelStore.js';
 import { meterIterable } from './MeteredStream.js';
-import { send, subscribe, toText } from './Transports.js';
+import { send, subscribe, toText, WebSocketOutboundBufferLimitError, } from './Transports.js';
 /** Public WebSocket payment frame helpers. */
 export { formatApplicationMessage, formatAuthorizationMessage, formatCloseReadyMessage, formatCloseRequestMessage, formatErrorMessage, formatNeedVoucherMessage, formatReceiptMessage, parseMessage, } from '../precompile/Protocol.js';
 /**
@@ -17,10 +17,11 @@ export { formatApplicationMessage, formatAuthorizationMessage, formatCloseReadyM
  * HTTP-specific context beyond the `Authorization` header.
  */
 export async function serve(options) {
-    const { amount: expectedAmount, generate, pollIntervalMs = 100, route, socket, store: rawStore, url, } = options;
+    const { amount: expectedAmount, generate, maxIncomingMessageBytes = 64 * 1024, maxBufferedAmount = 1024 * 1024, pollIntervalMs = 100, route, socket, store: rawStore, url, } = options;
     const store = 'getChannel' in rawStore ? rawStore : ChannelStore.fromStore(rawStore);
     const requestUrl = normalizeHttpUrl(url);
     const maxQueuedPaymentMessages = 32;
+    const sendFrame = (data) => send(socket, data, { maxBufferedAmount });
     const abortController = new AbortController();
     const runtime = {
         closed: false,
@@ -55,7 +56,7 @@ export async function serve(options) {
             spent: channel.spent,
             units: channel.units,
         });
-        await send(socket, formatCloseReadyMessage(receipt));
+        await sendFrame(formatCloseReadyMessage(receipt));
     };
     const runStream = async (context) => {
         try {
@@ -67,23 +68,28 @@ export async function serve(options) {
                 onChargeCommitted: options.onChargeCommitted ?? options.settleScheduled,
                 pollIntervalMs,
                 signal: abortController.signal,
-                emitNeedVoucher: (message) => send(socket, message),
+                emitNeedVoucher: (message) => sendFrame(message),
                 formatNeedVoucher: formatNeedVoucherMessage,
             })) {
                 if (abortController.signal.aborted)
                     break;
-                await send(socket, formatApplicationMessage(value));
+                await sendFrame(formatApplicationMessage(value));
             }
             if (!abortController.signal.aborted)
                 await sendCloseReady();
         }
         catch (error) {
             if (!abortController.signal.aborted) {
-                await send(socket, formatErrorMessage({
-                    message: error instanceof Error ? error.message : 'websocket session failed',
-                    status: 500,
-                }));
-                await close(1011, 'websocket session failed');
+                if (error instanceof WebSocketOutboundBufferLimitError) {
+                    await close(4008, 'outbound buffer limit exceeded').catch(() => { });
+                }
+                else {
+                    await sendFrame(formatErrorMessage({
+                        message: error instanceof Error ? error.message : 'websocket session failed',
+                        status: 500,
+                    })).catch(() => { });
+                    await close(1011, 'websocket session failed').catch(() => { });
+                }
             }
         }
         finally {
@@ -109,7 +115,7 @@ export async function serve(options) {
         if (payload.action === 'close')
             runtime.closeRequested = true;
         if (expectedAmount && credential.challenge.request.amount !== expectedAmount) {
-            await send(socket, formatErrorMessage({
+            await sendFrame(formatErrorMessage({
                 message: 'credential amount does not match this endpoint',
                 status: 402,
             }));
@@ -118,7 +124,7 @@ export async function serve(options) {
         }
         const authorizationResult = await authorizePaymentFrame({ authorization, requestUrl, route });
         if (authorizationResult.status === 'rejected') {
-            await send(socket, formatErrorMessage({
+            await sendFrame(formatErrorMessage({
                 message: authorizationResult.message,
                 status: authorizationResult.responseStatus,
             }));
@@ -129,7 +135,7 @@ export async function serve(options) {
         if (payload.action === 'voucher' && runtime.streamContext) {
             runtime.streamContext.challengeId = credential.challenge.id;
         }
-        await send(socket, formatReceiptMessage(receipt));
+        await sendFrame(formatReceiptMessage(receipt));
         if (payload.action === 'close') {
             await close(1000, 'payment session closed');
             return;
@@ -155,6 +161,15 @@ export async function serve(options) {
     const onMessage = (payload) => {
         if (runtime.closed)
             return;
+        const messageBytes = frameByteLength(payload);
+        if (messageBytes !== null && messageBytes > maxIncomingMessageBytes) {
+            runtime.closed = true;
+            abortController.abort();
+            unsubscribe();
+            void send(socket, formatErrorMessage({ message: 'payment message is too large', status: 413 })).catch(() => { });
+            void Promise.resolve(socket.close(1009, 'payment message is too large')).catch(() => { });
+            return;
+        }
         const raw = toText(payload);
         if (!raw)
             return;
@@ -173,7 +188,7 @@ export async function serve(options) {
         if (!work)
             return;
         if (runtime.queuedActions >= maxQueuedPaymentMessages) {
-            void send(socket, formatErrorMessage({
+            void sendFrame(formatErrorMessage({
                 message: 'too many queued payment messages',
                 status: 429,
             })).catch(() => { });
@@ -194,11 +209,16 @@ export async function serve(options) {
         })
             .catch(async (error) => {
             if (!runtime.closed) {
-                await send(socket, formatErrorMessage({
-                    message: error instanceof Error ? error.message : 'invalid payment message',
-                    status: 400,
-                }));
-                await close(1008, 'invalid payment message');
+                if (error instanceof WebSocketOutboundBufferLimitError) {
+                    await close(4008, 'outbound buffer limit exceeded').catch(() => { });
+                }
+                else {
+                    await sendFrame(formatErrorMessage({
+                        message: error instanceof Error ? error.message : 'invalid payment message',
+                        status: 400,
+                    })).catch(() => { });
+                    await close(1008, 'invalid payment message').catch(() => { });
+                }
             }
         });
     };
@@ -215,6 +235,41 @@ export async function serve(options) {
         message: onMessage,
     });
 }
+function frameByteLength(value) {
+    if (value instanceof ArrayBuffer)
+        return value.byteLength;
+    if (ArrayBuffer.isView(value))
+        return value.byteLength;
+    if (typeof Blob !== 'undefined' && value instanceof Blob)
+        return value.size;
+    if (Array.isArray(value)) {
+        let bytes = 0;
+        for (const fragment of value) {
+            const fragmentBytes = frameByteLength(fragment);
+            if (fragmentBytes === null)
+                return null;
+            bytes += fragmentBytes;
+        }
+        return bytes;
+    }
+    if (typeof value !== 'string')
+        return null;
+    let bytes = 0;
+    for (let index = 0; index < value.length; index++) {
+        const codePoint = value.codePointAt(index);
+        if (codePoint <= 0x7f)
+            bytes += 1;
+        else if (codePoint <= 0x7ff)
+            bytes += 2;
+        else if (codePoint <= 0xffff)
+            bytes += 3;
+        else {
+            bytes += 4;
+            index += 1;
+        }
+    }
+    return bytes;
+}
 function normalizeHttpUrl(value) {
     const url = new URL(value.toString());
     if (url.protocol === 'ws:')
@@ -239,7 +294,7 @@ async function authorizePaymentFrame(parameters) {
             responseStatus: response.status,
         };
     }
-    const response = result.withReceipt(new Response(null, { status: 204 }));
+    const response = await result.withReceipt(new Response(null, { status: 204 }));
     const receiptHeader = response.headers.get(Constants.Headers.paymentReceipt);
     if (!receiptHeader)
         throw new Error('management response missing Payment-Receipt header');

package/dist/tempo/subscription/KeyAuthorization.d.ts

@@ -74,7 +74,7 @@ export declare function signSubscriptionKeyAuthorization(parameters: {
         };
         type: 'p256';
         account?: undefined;
-        init?: undefined;
+        config?: undefined;
         inner?: undefined;
         keyId?: undefined;
         metadata?: undefined;
@@ -89,7 +89,7 @@ export declare function signSubscriptionKeyAuthorization(parameters: {
         };
         type: 'secp256k1';
         account?: undefined;
-        init?: undefined;
+        config?: undefined;
         inner?: undefined;
         keyId?: undefined;
         metadata?: undefined;
@@ -103,25 +103,87 @@ export declare function signSubscriptionKeyAuthorization(parameters: {
             authenticatorData: Hex.Hex;
             clientDataJSON: string;
         };
-        signature: {
-            r: bigint;
-            s: bigint;
-            yParity?: number | undefined;
-        };
         publicKey: {
             prefix: number;
             x: bigint;
             y: bigint;
         };
+        signature: {
+            r: bigint;
+            s: bigint;
+            yParity?: number | undefined;
+        };
         type: 'webAuthn';
         account?: undefined;
-        init?: undefined;
+        config?: undefined;
         inner?: undefined;
         keyId?: undefined;
         prehash?: undefined;
         signatures?: undefined;
         userAddress?: undefined;
         version?: undefined;
+    } | {
+        account: import("ox/Address").Address;
+        config: {
+            owners: readonly {
+                owner: import("ox/Address").Address;
+                weight: number;
+            }[];
+            salt: Hex.Hex;
+            threshold: number;
+            version: bigint;
+        };
+        signatures: readonly ({
+            prehash: boolean;
+            publicKey: {
+                prefix: number;
+                x: bigint;
+                y: bigint;
+            };
+            signature: {
+                r: bigint;
+                s: bigint;
+                yParity?: number | undefined;
+            };
+            type: 'p256';
+            metadata?: undefined;
+        } | {
+            signature: {
+                r: bigint;
+                s: bigint;
+                yParity: number;
+            };
+            type: 'secp256k1';
+            metadata?: undefined;
+            prehash?: undefined;
+            publicKey?: undefined;
+        } | {
+            metadata: {
+                authenticatorData: Hex.Hex;
+                clientDataJSON: string;
+            };
+            publicKey: {
+                prefix: number;
+                x: bigint;
+                y: bigint;
+            };
+            signature: {
+                r: bigint;
+                s: bigint;
+                yParity?: number | undefined;
+            };
+            type: 'webAuthn';
+            prehash?: undefined;
+        })[];
+        type: 'multisig';
+        inner?: undefined;
+        keyId?: undefined;
+        metadata?: undefined;
+        prehash?: undefined;
+        publicKey?: undefined;
+        signature?: undefined;
+        userAddress?: undefined;
+        version?: undefined;
     };
     readonly address: `0x${string}`;
     readonly chainId: bigint;

package/dist/tempo/subscription/Store.d.ts

@@ -6,6 +6,8 @@ export type SubscriptionStore = {
     activate<result extends {
         subscription: SubscriptionRecord;
     }>(parameters: ActivateParameters<result>): Promise<ActivateResult<result>>;
+    /** Releases a transient credential claim so the same challenge can be retried. */
+    releaseCredential(challengeId: string): Promise<void>;
     /** Looks up a subscription by subscription ID. */
     get(subscriptionId: string): Promise<SubscriptionRecord | null>;
     /** Looks up a generated access key for a resolved request key. */

package/dist/tempo/subscription/Store.js

@@ -146,6 +146,9 @@ export function fromStore(store, options) {
             await clearActivationState(subscription.lookupKey, challengeId);
             return { status: 'activated', result };
         },
+        async releaseCredential(challengeId) {
+            await store.delete(credentialKey(challengeId));
+        },
         async get(subscriptionId) {
             return (await store.get(recordKey(subscriptionId)));
         },

package/dist/validation/core.js

@@ -35,6 +35,7 @@ export async function* validateStream(options) {
         });
         const effectiveBody = resolvedBody ?? body;
         const isMpp = challengeResults.some((r) => r.severity === 'pass' && r.label === 'Challenge parseable');
+        const challengeIsValid = !challengeResults.some((result) => result.severity === 'fail');
         const chainIds = (parsedChallenges ?? [])
             .filter((ch) => ch.method !== 'stripe')
             .map((ch) => ch.request.methodDetails?.chainId)
@@ -63,7 +64,7 @@ export async function* validateStream(options) {
                 query: options.query,
             });
             yield { phase: 'errorHandling', endpoint, results: errorResults };
-            if (!options.skipPayment) {
+            if (!options.skipPayment && challengeIsValid) {
                 const onResults = options.onPaymentResults;
                 const paymentResults = await validatePaymentFlow(baseUrl, endpoint, verbose, {
                     body: effectiveBody,

package/dist/x402/server/EvmCharge.d.ts

@@ -25,7 +25,7 @@ export type Options = {
      * and client bugs, not an active attacker. Body binding is unaffected either
      * way — `challenge.digest` is verified against the actual body.
      *
-     * @default 'resource'
+     * @default 'required'
      */
     routeBinding?: RouteBindingMode | undefined;
 };
@@ -38,8 +38,10 @@ export type ResolvedOptions = {
     routeBinding: RouteBindingMode;
 };
 export type Path = {
+    credentialHeaders: readonly string[];
     bindCredential: NonNullable<ServerTransport.Http['bindCredential']>;
     getCredential: ServerTransport.Http['getCredential'];
+    matchCredential: NonNullable<ServerTransport.Http['matchCredential']>;
     respondChallenge: (options: Parameters<ServerTransport.Http['respondChallenge']>[0], response?: Response | undefined) => Response | Promise<Response>;
     respondReceipt: (options: Parameters<ServerTransport.Http['respondReceipt']>[0], response: Response) => Response;
 };

package/dist/x402/server/EvmCharge.js

@@ -37,12 +37,13 @@ export function resolveOptions(parameters) {
             }
             : {}),
         maxTimeoutSeconds: parameters.options?.maxTimeoutSeconds ?? 300,
-        routeBinding: parameters.options?.routeBinding ?? 'resource',
+        routeBinding: parameters.options?.routeBinding ?? 'required',
     };
 }
 /** Creates the x402 wire path for an EVM charge method. */
 export function createPath(config) {
     return {
+        credentialHeaders: [x402_Types.paymentSignatureHeader],
         getCredential(request) {
             const paymentSignature = request.headers.get(x402_Types.paymentSignatureHeader);
             if (!paymentSignature)
@@ -53,6 +54,18 @@ export function createPath(config) {
                 payload: paymentPayload,
             }));
         },
+        matchCredential({ input, request }) {
+            const paymentSignature = input.headers.get(x402_Types.paymentSignatureHeader);
+            if (!paymentSignature)
+                return false;
+            try {
+                const paymentPayload = x402_Header.decodePaymentSignature(paymentSignature);
+                return isDeepStrictEqual(paymentPayload.accepted, toPaymentRequirements(request, config));
+            }
+            catch {
+                return false;
+            }
+        },
         async bindCredential({ challenge, credential, input }) {
             const paymentPayload = parsePaymentPayload(credential.payload);
             if (!paymentPayload)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mppx",
   "type": "module",
-  "version": "0.11.0",
+  "version": "0.13.1",
   "main": "./dist/index.js",
   "license": "MIT",
   "homepage": "https://github.com/wevm/mppx#readme",
@@ -163,11 +163,11 @@
     "@x402/hono": ">=2.22.0",
     "@x402/mcp": ">=2.22.0",
     "@x402/next": ">=2.22.0",
-    "elysia": ">=1",
+    "elysia": ">=1.2.0",
     "express": ">=5",
     "hono": ">=4.12.25",
     "next": ">=16.2.6",
-    "viem": ">=2.54.0"
+    "viem": ">=2.57.1"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/sdk": {
@@ -202,11 +202,11 @@
     }
   },
   "dependencies": {
-    "@stripe/stripe-js": "9.13.0",
-    "eventsource-parser": "3.1.1",
-    "ox": "0.14.33",
-    "structured-headers": "2.0.3",
-    "zod": "^4.4.3"
+    "@stripe/stripe-js": "9.17.0",
+    "eventsource-parser": "4.1.1",
+    "ox": "0.14.45",
+    "structured-headers": "2.1.0",
+    "zod": "^4.6.5"
   },
   "repository": {
     "type": "git",

package/dist/tempo/legacy/client/ChannelOps.d.ts

@@ -1,69 +0,0 @@
-/**
- * Shared client-side channel operations.
- *
- * Provides the low-level helpers that both `session()`
- * and `sessionManager()` (orchestrator) rely on: escrow resolution, channel
- * ID computation, on-chain open/voucher/close payload construction, channel
- * recovery from on-chain state, and credential serialization.
- */
-import { Hex } from 'ox';
-import { type Address, type Account as viem_Account, type Client as viem_Client } from 'viem';
-import type { Challenge } from '../../../Challenge.js';
-import type { LegacySessionCredentialPayload } from '../session/Types.js';
-/** Cached channel metadata used by the legacy auto-driving session client. */
-export type ChannelEntry = {
-    /** Voucher authority the channel was opened with. */
-    authorizedSigner: Address;
-    /** Legacy contract-backed channel ID. */
-    channelId: Hex.Hex;
-    /** Salt used to derive the channel ID. */
-    salt: Hex.Hex;
-    /** Highest cumulative voucher amount locally authorized. */
-    cumulativeAmount: bigint;
-    /** Escrow contract backing this channel. */
-    escrowContract: Address;
-    /** Chain ID used for channel ID and voucher domain separation. */
-    chainId: number;
-    /** Whether the client considers the channel reusable. */
-    opened: boolean;
-};
-/** Resolves the chain ID embedded in a legacy session challenge. */
-export declare function resolveChainId(challenge: Challenge): number;
-/** Resolves the server-advertised escrow against the client's trust policy. */
-export declare function resolveEscrow(challenge: {
-    request: {
-        methodDetails?: unknown;
-    };
-}, chainId: number, escrowContractOverride?: Address, allowCustomEscrow?: boolean): Address;
-/** Serializes a legacy session credential with a payer DID source. */
-export declare function serializeCredential(challenge: Challenge, payload: LegacySessionCredentialPayload, chainId: number, account: viem_Account): string;
-/** Creates a legacy cumulative voucher credential payload. */
-export declare function createVoucherPayload(client: viem_Client, account: viem_Account, channelId: Hex.Hex, cumulativeAmount: bigint, escrowContract: Address, chainId: number, voucherSigner?: viem_Account | undefined): Promise<LegacySessionCredentialPayload>;
-/** Creates a legacy cooperative close credential payload. */
-export declare function createClosePayload(client: viem_Client, account: viem_Account, channelId: Hex.Hex, cumulativeAmount: bigint, escrowContract: Address, chainId: number, voucherSigner?: viem_Account | undefined): Promise<LegacySessionCredentialPayload>;
-/** Creates a legacy open transaction credential payload and local channel entry. */
-export declare function createOpenPayload(client: viem_Client, account: viem_Account, options: {
-    voucherSigner?: viem_Account | undefined;
-    escrowContract: Address;
-    payee: Address;
-    currency: Address;
-    deposit: bigint;
-    initialAmount: bigint;
-    chainId: number;
-    feePayer?: boolean | undefined;
-}): Promise<{
-    entry: ChannelEntry;
-    payload: LegacySessionCredentialPayload;
-}>;
-/**
- * Attempt to recover an existing on-chain channel by reading its state.
- *
- * If the channel has a positive deposit and is not finalized, returns a
- * {@link ChannelEntry} with `cumulativeAmount` set to the on-chain settled
- * amount (the safe starting point for new vouchers).
- *
- * Returns `undefined` if the channel doesn't exist, has zero deposit,
- * or is already finalized.
- */
-export declare function tryRecoverChannel(client: viem_Client, escrowContract: Address, channelId: Hex.Hex, chainId: number): Promise<ChannelEntry | undefined>;
-//# sourceMappingURL=ChannelOps.d.ts.map

package/dist/tempo/legacy/client/ChannelOps.js

@@ -1,168 +0,0 @@
-/**
- * Shared client-side channel operations.
- *
- * Provides the low-level helpers that both `session()`
- * and `sessionManager()` (orchestrator) rely on: escrow resolution, channel
- * ID computation, on-chain open/voucher/close payload construction, channel
- * recovery from on-chain state, and credential serialization.
- */
-import { Hex } from 'ox';
-import { encodeFunctionData, } from 'viem';
-import { prepareTransactionRequest, signTransaction } from 'viem/actions';
-import { Abis } from 'viem/tempo';
-import * as Credential from '../../../Credential.js';
-import { getAccountSignerAddress } from '../../internal/account.js';
-import * as defaults from '../../internal/defaults.js';
-import { escrowAbi, getOnChainChannel } from '../session/Chain.js';
-import * as Channel from '../session/Channel.js';
-import { signVoucher } from '../session/Voucher.js';
-function resolveVoucherSigner(account, voucherSigner) {
-    return voucherSigner ?? account;
-}
-/** Resolves the chain ID embedded in a legacy session challenge. */
-export function resolveChainId(challenge) {
-    const md = challenge.request.methodDetails;
-    return md?.chainId ?? 0;
-}
-/** Resolves the server-advertised escrow against the client's trust policy. */
-export function resolveEscrow(challenge, chainId, escrowContractOverride, allowCustomEscrow = false) {
-    const challengeEscrow = challenge.request.methodDetails
-        ?.escrowContract;
-    const escrow = escrowContractOverride ??
-        defaults.escrowContract[chainId];
-    if (!escrow && !(allowCustomEscrow && challengeEscrow))
-        throw new Error('No trusted `escrowContract` available. Provide it in client parameters or use a supported chain.');
-    if (challengeEscrow &&
-        escrow &&
-        challengeEscrow.toLowerCase() !== escrow.toLowerCase() &&
-        (!allowCustomEscrow || escrowContractOverride !== undefined))
-        throw new Error(`Tempo session escrow ${challengeEscrow} does not match client escrow ${escrow}.`);
-    if (challengeEscrow && (!escrow || challengeEscrow.toLowerCase() !== escrow.toLowerCase()))
-        return challengeEscrow;
-    return escrow;
-}
-/** Serializes a legacy session credential with a payer DID source. */
-export function serializeCredential(challenge, payload, chainId, account) {
-    return Credential.serialize({
-        challenge,
-        payload,
-        source: `did:pkh:eip155:${chainId}:${account.address}`,
-    });
-}
-/** Creates a legacy cumulative voucher credential payload. */
-export async function createVoucherPayload(client, account, channelId, cumulativeAmount, escrowContract, chainId, voucherSigner) {
-    const signer = resolveVoucherSigner(account, voucherSigner);
-    const signature = await signVoucher(client, account, { channelId, cumulativeAmount }, escrowContract, chainId, signer);
-    return {
-        action: 'voucher',
-        channelId,
-        cumulativeAmount: cumulativeAmount.toString(),
-        signature,
-    };
-}
-/** Creates a legacy cooperative close credential payload. */
-export async function createClosePayload(client, account, channelId, cumulativeAmount, escrowContract, chainId, voucherSigner) {
-    const signer = resolveVoucherSigner(account, voucherSigner);
-    const signature = await signVoucher(client, account, { channelId, cumulativeAmount }, escrowContract, chainId, signer);
-    return {
-        action: 'close',
-        channelId,
-        cumulativeAmount: cumulativeAmount.toString(),
-        signature,
-    };
-}
-/** Creates a legacy open transaction credential payload and local channel entry. */
-export async function createOpenPayload(client, account, options) {
-    const { escrowContract, payee, currency, deposit, initialAmount, chainId, feePayer } = options;
-    const voucherSigner = resolveVoucherSigner(account, options.voucherSigner);
-    const authorizedSigner = getAccountSignerAddress(voucherSigner);
-    const salt = Hex.random(32);
-    const channelId = Channel.computeId({
-        authorizedSigner,
-        chainId,
-        escrowContract,
-        payee,
-        payer: account.address,
-        salt,
-        token: currency,
-    });
-    const approveData = encodeFunctionData({
-        abi: Abis.tip20,
-        functionName: 'approve',
-        args: [escrowContract, deposit],
-    });
-    const openData = encodeFunctionData({
-        abi: escrowAbi,
-        functionName: 'open',
-        args: [payee, currency, deposit, salt, authorizedSigner],
-    });
-    const validBefore = Math.floor(Date.now() / 1_000) + 25;
-    const prepared = await prepareTransactionRequest(client, {
-        account,
-        calls: [
-            { to: currency, data: approveData },
-            { to: escrowContract, data: openData },
-        ],
-        feeToken: currency,
-        nonceKey: 'expiring',
-        validBefore,
-    });
-    // Estimate before enabling fee-payer mode so Tempo includes sender
-    // signature and access-key verification costs in the gas budget.
-    prepared.gas = (prepared.gas ?? 0n) + 5000n;
-    if (feePayer)
-        prepared.feePayer = true;
-    const transaction = (await signTransaction(client, prepared));
-    const signature = await signVoucher(client, account, { channelId, cumulativeAmount: initialAmount }, escrowContract, chainId, voucherSigner);
-    return {
-        entry: {
-            authorizedSigner,
-            channelId,
-            salt,
-            cumulativeAmount: initialAmount,
-            escrowContract,
-            chainId,
-            opened: true,
-        },
-        payload: {
-            action: 'open',
-            type: 'transaction',
-            channelId,
-            transaction,
-            authorizedSigner,
-            cumulativeAmount: initialAmount.toString(),
-            signature,
-        },
-    };
-}
-/**
- * Attempt to recover an existing on-chain channel by reading its state.
- *
- * If the channel has a positive deposit and is not finalized, returns a
- * {@link ChannelEntry} with `cumulativeAmount` set to the on-chain settled
- * amount (the safe starting point for new vouchers).
- *
- * Returns `undefined` if the channel doesn't exist, has zero deposit,
- * or is already finalized.
- */
-export async function tryRecoverChannel(client, escrowContract, channelId, chainId) {
-    try {
-        const onChain = await getOnChainChannel(client, escrowContract, channelId);
-        if (onChain.deposit > 0n && !onChain.finalized) {
-            return {
-                // A zero on-chain authorizedSigner means the escrow verifies vouchers
-                // against the payer, so record the payer as the voucher authority.
-                authorizedSigner: BigInt(onChain.authorizedSigner) === 0n ? onChain.payer : onChain.authorizedSigner,
-                channelId,
-                salt: '0x',
-                cumulativeAmount: onChain.settled,
-                escrowContract,
-                chainId,
-                opened: true,
-            };
-        }
-    }
-    catch { }
-    return undefined;
-}
-//# sourceMappingURL=ChannelOps.js.map