mppx 0.8.15 → 0.8.18

package/dist/tempo/session/client/Transports.js

@@ -440,6 +440,7 @@ export async function closeHttpSession(parameters) {
             challengeId: closeChallenge.id,
             channelId: parameters.target.channelId,
             expectedCloseAmount: signedCloseAmount,
+            minimumSpent: parameters.getMinimumSpent?.() ?? 0n,
             receipt,
         }))
         throw new Error('Session close response included a mismatched payment receipt.');
@@ -698,7 +699,10 @@ export function isExpectedSocketReceipt(parameters) {
 export function validateSocketCloseReadyReceipt(parameters) {
     if (!isExpectedSocketReceipt(parameters))
         return 'received mismatched payment-close-ready frame';
-    if (BigInt(parameters.receipt.spent) > parameters.cumulativeAmount) {
+    const spent = Ws.parseUint96Amount(parameters.receipt.spent);
+    if (spent === undefined)
+        return 'received invalid payment-close-ready spend';
+    if (spent > parameters.cumulativeAmount) {
         return 'received payment-close-ready beyond local voucher state';
     }
     return undefined;
@@ -710,7 +714,13 @@ export function validateSocketPaymentReceipt(parameters) {
         return 'received mismatched payment-receipt frame';
     if (expectedCloseAmount !== null &&
         Boolean(receipt.txHash) &&
-        !isExpectedCloseReceipt({ challengeId, channelId, expectedCloseAmount, receipt })) {
+        !isExpectedCloseReceipt({
+            challengeId,
+            channelId,
+            expectedCloseAmount,
+            minimumSpent: BigInt(expectedCloseAmount),
+            receipt,
+        })) {
         return 'received mismatched payment-close receipt frame';
     }
     return undefined;

package/dist/tempo/session/precompile/Chain.d.ts

@@ -177,17 +177,28 @@ export type ChannelTransactionOptions = {
     account?: Account | undefined;
     /** Candidate fee tokens used when resolving a fee token for fee-sponsored transactions. */
     candidateFeeTokens?: readonly Address[] | undefined;
-    /** Fee-payer account used to co-sign Tempo fee-sponsored transactions. */
-    feePayer?: Account | undefined;
+    /** Fee-payer account, or `true` when the client transport uses a configured hosted fee-payer service. */
+    feePayer?: Account | true | undefined;
     /** Optional fee-payer gas and total-fee limits enforced before co-signing. */
     feePayerPolicy?: Partial<FeePayer.Policy> | undefined;
     /** Explicit fee token for the transaction. */
     feeToken?: Address | undefined;
 };
+/** Simulates an unsponsored client-signed session transaction without broadcasting it. */
+export declare function simulateCredentialTransaction(parameters: {
+    /** viem client used for the read-only execution simulation. */
+    client: TransactionClient;
+    /** Fee-payer configuration for the eventual broadcast. Sponsored transactions are simulated after completion. */
+    feePayer?: Account | true | undefined;
+    /** Parsed client-signed Tempo transaction. */
+    transaction: ReturnType<(typeof Transaction)['deserialize']>;
+}): Promise<void>;
 /**
  * Submit a settle transaction on-chain.
  */
 export declare function settleOnChain(client: Client, descriptor: ChannelDescriptor, cumulativeAmount: bigint, signature: Hex, escrow?: Address, options?: ChannelTransactionOptions): Promise<Hex>;
+/** Submit a settle transaction through the first-party machine-token session router. */
+export declare function settleMachineSessionOnChain(client: Client, descriptor: ChannelDescriptor, cumulativeAmount: bigint, signature: Hex, authorizationSignature: Hex, router: Address, options?: ChannelTransactionOptions): Promise<Hex>;
 /**
  * Submit a top-up transaction on-chain.
  */
@@ -204,6 +215,8 @@ export declare function withdrawOnChain(client: Client, descriptor: ChannelDescr
  * Submit a close transaction on-chain.
  */
 export declare function closeOnChain(client: Client, descriptor: ChannelDescriptor, cumulativeAmount: bigint, captureAmount: bigint, signature: Hex, escrow?: Address, options?: ChannelTransactionOptions): Promise<Hex>;
+/** Submit a cooperative close through the first-party machine-token session router. */
+export declare function closeMachineSessionOnChain(client: Client, descriptor: ChannelDescriptor, cumulativeAmount: bigint, signature: Hex, authorizationSignature: Hex, refundSignature: Hex, router: Address, options?: ChannelTransactionOptions): Promise<Hex>;
 /** Receipt event shape emitted by TIP20EscrowChannel precompile management calls. */
 export type ChannelReceiptEvent = {
     args: {
@@ -270,6 +283,8 @@ export type BroadcastOpenTransactionResult = {
 };
 /** Inputs for broadcasting and verifying a client-signed TIP-1034 open transaction. */
 export type BroadcastOpenTransactionParameters = {
+    /** Fee tokens allowed when the server completes a sponsored transaction. Defaults to the channel currency. */
+    allowedFeeTokens?: readonly Address[] | undefined;
     /** Hook invoked after calldata validation but before broadcasting. */
     beforeBroadcast?: ((result: Omit<BroadcastOpenTransactionResult, 'txHash' | 'state'>) => Promise<void> | void) | undefined;
     /** Challenge expiration propagated into fee-payer policy checks. */
@@ -301,6 +316,15 @@ export type BroadcastOpenTransactionParameters = {
     /** Client-signed serialized open transaction. */
     serializedTransaction: Hex;
 };
+/** Inputs for validating a client-signed TIP-1034 open transaction without broadcasting it. */
+export type ValidateOpenCredentialTransactionParameters = Omit<BroadcastOpenTransactionParameters, 'beforeBroadcast' | 'client'>;
+/** Validated fields recovered from a client-signed TIP-1034 open transaction. */
+export type ValidatedOpenCredentialTransaction = Omit<BroadcastOpenTransactionResult, 'state' | 'txHash'> & {
+    /** Parsed client-signed transaction, reused by simulation and broadcast. */
+    transaction: ReturnType<(typeof Transaction)['deserialize']>;
+};
+/** Validates the immutable fields of a client-signed TIP-1034 open transaction. */
+export declare function validateOpenCredentialTransaction(parameters: ValidateOpenCredentialTransactionParameters): ValidatedOpenCredentialTransaction;
 /** Broadcast and validate a client-signed TIP-1034 open transaction. */
 export declare function broadcastOpenTransaction(parameters: BroadcastOpenTransactionParameters): Promise<BroadcastOpenTransactionResult>;
 /** Result returned after a TIP-1034 top-up transaction is broadcast and verified. */
@@ -316,6 +340,8 @@ export type BroadcastTopUpTransactionResult = {
 export type BroadcastTopUpTransactionParameters = {
     /** Additional deposit amount expected in the top-up calldata. */
     additionalDeposit: bigint;
+    /** Fee tokens allowed when the server completes a sponsored transaction. Defaults to the channel currency. */
+    allowedFeeTokens?: readonly Address[] | undefined;
     /** Challenge expiration propagated into fee-payer policy checks. */
     challengeExpires?: string | undefined;
     /** Chain ID used for fee-payer transaction signing. */
@@ -337,6 +363,15 @@ export type BroadcastTopUpTransactionParameters = {
     /** Client-signed serialized top-up transaction. */
     serializedTransaction: Hex;
 };
+/** Inputs for validating a client-signed TIP-1034 top-up transaction without broadcasting it. */
+export type ValidateTopUpCredentialTransactionParameters = Omit<BroadcastTopUpTransactionParameters, 'client'>;
+/** Validated fields recovered from a client-signed TIP-1034 top-up transaction. */
+export type ValidatedTopUpCredentialTransaction = {
+    /** Parsed client-signed transaction, reused by simulation and broadcast. */
+    transaction: ReturnType<(typeof Transaction)['deserialize']>;
+};
+/** Validates the immutable fields of a client-signed TIP-1034 top-up transaction. */
+export declare function validateTopUpCredentialTransaction(parameters: ValidateTopUpCredentialTransactionParameters): ValidatedTopUpCredentialTransaction;
 /** Broadcast and validate a client-signed TIP-1034 top-up transaction. */
 export declare function broadcastTopUpTransaction(parameters: BroadcastTopUpTransactionParameters): Promise<BroadcastTopUpTransactionResult>;
 export {};

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

@@ -1,4 +1,4 @@
-import { decodeFunctionData, encodeFunctionData, isAddressEqual, parseEventLogs } from 'viem';
+import { decodeFunctionData, encodeFunctionData, isAddressEqual, parseAbi, parseEventLogs, } from 'viem';
 import { call, prepareTransactionRequest, readContract, sendRawTransaction, sendRawTransactionSync, sendTransaction as sendViemTransaction, signTransaction, waitForTransactionReceipt, } from 'viem/actions';
 import { Abis, Addresses, Transaction } from 'viem/tempo';
 import { BadRequestError, VerificationFailedError } from '../../../Errors.js';
@@ -8,6 +8,10 @@ import * as ChannelOps from '../server/ChannelOps.js';
 import * as ChannelUtils from './Channel.js';
 import { escrowAbi } from './escrow.abi.js';
 import { tip20ChannelEscrow } from './Protocol.js';
+const machineSessionAbi = parseAbi([
+    'function settleSession((address payer,address payee,address operator,address token,bytes32 salt,address authorizedSigner,bytes32 expiringNonceHash) descriptor,uint96 cumulativeAmount,bytes signature,bytes authorizationSignature)',
+    'function closeSession((address payer,address payee,address operator,address token,bytes32 salt,address authorizedSigner,bytes32 expiringNonceHash) descriptor,uint96 cumulativeAmount,bytes signature,bytes authorizationSignature,bytes refundSignature)',
+]);
 const uint96Max = 2n ** 96n - 1n;
 function readBytes32(value, label) {
     if (typeof value === 'string' && /^0x[0-9a-fA-F]{64}$/.test(value))
@@ -284,6 +288,29 @@ async function simulateTempoTransaction(client, request) {
     // fee-payer fields together. Keep that compatibility cast in one place.
     await call(client, request);
 }
+/** Simulates an unsponsored client-signed session transaction without broadcasting it. */
+export async function simulateCredentialTransaction(parameters) {
+    if (parameters.feePayer)
+        return;
+    await simulateTempoTransaction(parameters.client, FeePayer.simulationTransaction(parameters.transaction, { feePayer: false }));
+}
+function validateCredentialSponsorship(parameters) {
+    const { allowedFeeTokens, challengeExpires, chainId, details, feePayer, feePayerPolicy, transaction, } = parameters;
+    if (!feePayer || feePayer === true)
+        return;
+    FeePayer.prepareSponsoredTransaction({
+        account: feePayer,
+        allowedFeeTokens,
+        challengeExpires,
+        chainId,
+        details,
+        policy: feePayerPolicy,
+        transaction: {
+            ...transaction,
+            ...(allowedFeeTokens[0] ? { feeToken: transaction.feeToken ?? allowedFeeTokens[0] } : {}),
+        },
+    });
+}
 async function signTempoTransaction(client, transaction) {
     return (await signTransaction(client, transaction));
 }
@@ -299,13 +326,14 @@ async function prepareFeePayerCallTransaction(client, parameters) {
     });
 }
 function sendPrecompileContractCall(client, parameters) {
-    const { account, data, feeToken, to } = parameters;
+    const { account, data, feePayer, feeToken, to } = parameters;
     // `feeToken` is Tempo-specific and not represented on viem's base
     // transaction request type.
     return sendViemTransaction(client, {
         ...(account ? { account } : {}),
         to,
         data,
+        ...(feePayer ? { feePayer } : {}),
         ...(feeToken ? { feeToken } : {}),
     });
 }
@@ -317,6 +345,26 @@ export async function settleOnChain(client, descriptor, cumulativeAmount, signat
     const args = [descriptorTuple(descriptor), cumulativeAmount, signature];
     return sendPrecompileTransaction(client, escrow, encodeFunctionData({ abi: escrowAbi, functionName: 'settle', args }), 'settle', options);
 }
+function encodeMachineSessionCall(descriptor, cumulativeAmount, signature, authorizationSignature, refundSignature) {
+    assertUint96(cumulativeAmount);
+    const args = [
+        descriptorTuple(descriptor),
+        cumulativeAmount,
+        signature,
+        authorizationSignature,
+    ];
+    return refundSignature === undefined
+        ? encodeFunctionData({ abi: machineSessionAbi, functionName: 'settleSession', args })
+        : encodeFunctionData({
+            abi: machineSessionAbi,
+            functionName: 'closeSession',
+            args: [...args, refundSignature],
+        });
+}
+/** Submit a settle transaction through the first-party machine-token session router. */
+export async function settleMachineSessionOnChain(client, descriptor, cumulativeAmount, signature, authorizationSignature, router, options) {
+    return sendPrecompileTransaction(client, router, encodeMachineSessionCall(descriptor, cumulativeAmount, signature, authorizationSignature), 'settle machine-token session', options);
+}
 /**
  * Submit a top-up transaction on-chain.
  */
@@ -348,6 +396,10 @@ export async function closeOnChain(client, descriptor, cumulativeAmount, capture
     const args = [descriptorTuple(descriptor), cumulativeAmount, captureAmount, signature];
     return sendPrecompileTransaction(client, escrow, encodeFunctionData({ abi: escrowAbi, functionName: 'close', args }), 'close', options);
 }
+/** Submit a cooperative close through the first-party machine-token session router. */
+export async function closeMachineSessionOnChain(client, descriptor, cumulativeAmount, signature, authorizationSignature, refundSignature, router, options) {
+    return sendPrecompileTransaction(client, router, encodeMachineSessionCall(descriptor, cumulativeAmount, signature, authorizationSignature, refundSignature), 'close machine-token session', options);
+}
 /**
  * Asserts that a deserialized transaction has an existing sender signature.
  */
@@ -430,8 +482,8 @@ export async function sendCredentialTransaction(parameters) {
         });
     return receipt;
 }
-/** Broadcast and validate a client-signed TIP-1034 open transaction. */
-export async function broadcastOpenTransaction(parameters) {
+/** Validates the immutable fields of a client-signed TIP-1034 open transaction. */
+export function validateOpenCredentialTransaction(parameters) {
     const { transaction, call, prefixCalls } = parsePrecompileCredentialTransaction({
         escrowContract: parameters.escrowContract,
         feePayer: parameters.feePayer,
@@ -464,6 +516,19 @@ export async function broadcastOpenTransaction(parameters) {
     });
     if (parameters.feePayer)
         assertSenderSigned(transaction);
+    validateCredentialSponsorship({
+        allowedFeeTokens: parameters.allowedFeeTokens ?? [parameters.expectedCurrency],
+        challengeExpires: parameters.challengeExpires,
+        chainId: parameters.chainId,
+        details: {
+            channelId: parameters.expectedChannelId,
+            currency: parameters.expectedCurrency,
+            recipient: parameters.expectedPayee,
+        },
+        feePayer: parameters.feePayer,
+        feePayerPolicy: parameters.feePayerPolicy,
+        transaction,
+    });
     const expiringNonceHash = ChannelUtils.computeExpiringNonceHash(ChannelUtils.transactionForExpiringNonceHash({
         feePayer: parameters.feePayer,
         transaction,
@@ -472,16 +537,21 @@ export async function broadcastOpenTransaction(parameters) {
         throw new VerificationFailedError({
             reason: 'credential expiringNonceHash does not match transaction',
         });
+    return { descriptor, expiringNonceHash, openDeposit: open.deposit, transaction };
+}
+/** Broadcast and validate a client-signed TIP-1034 open transaction. */
+export async function broadcastOpenTransaction(parameters) {
+    const { descriptor, expiringNonceHash, openDeposit, transaction } = validateOpenCredentialTransaction(parameters);
     await parameters.beforeBroadcast?.({
         descriptor,
         expiringNonceHash,
-        openDeposit: open.deposit,
+        openDeposit,
     });
     const receipt = await sendCredentialTransaction({
         challengeExpires: parameters.challengeExpires,
         chainId: parameters.chainId,
         client: parameters.client,
-        allowedFeeTokens: [parameters.expectedCurrency],
+        allowedFeeTokens: parameters.allowedFeeTokens ?? [parameters.expectedCurrency],
         details: {
             channelId: parameters.expectedChannelId,
             currency: parameters.expectedCurrency,
@@ -502,7 +572,7 @@ export async function broadcastOpenTransaction(parameters) {
         emittedExpiringNonceHash: opened.expiringNonceHash,
         escrow: parameters.escrowContract,
         expectedChannelId: parameters.expectedChannelId,
-        openDeposit: open.deposit,
+        openDeposit,
     });
     const chainChannel = await readbackWithRetry(() => getChannel(parameters.client, descriptor, parameters.escrowContract, receipt.blockNumber));
     const state = chainChannel.state;
@@ -512,11 +582,11 @@ export async function broadcastOpenTransaction(parameters) {
         descriptor,
         state,
         expiringNonceHash: opened.expiringNonceHash,
-        openDeposit: open.deposit,
+        openDeposit,
     };
 }
-/** Broadcast and validate a client-signed TIP-1034 top-up transaction. */
-export async function broadcastTopUpTransaction(parameters) {
+/** Validates the immutable fields of a client-signed TIP-1034 top-up transaction. */
+export function validateTopUpCredentialTransaction(parameters) {
     const { transaction, call, prefixCalls } = parsePrecompileCredentialTransaction({
         escrowContract: parameters.escrowContract,
         feePayer: parameters.feePayer,
@@ -536,11 +606,31 @@ export async function broadcastTopUpTransaction(parameters) {
         label: 'topUp',
         prefixCalls,
     });
+    if (parameters.feePayer)
+        assertSenderSigned(transaction);
+    validateCredentialSponsorship({
+        allowedFeeTokens: parameters.allowedFeeTokens ?? [parameters.expectedCurrency],
+        challengeExpires: parameters.challengeExpires,
+        chainId: parameters.chainId,
+        details: {
+            additionalDeposit: parameters.additionalDeposit.toString(),
+            channelId: parameters.expectedChannelId,
+            currency: parameters.expectedCurrency,
+        },
+        feePayer: parameters.feePayer,
+        feePayerPolicy: parameters.feePayerPolicy,
+        transaction,
+    });
+    return { transaction };
+}
+/** Broadcast and validate a client-signed TIP-1034 top-up transaction. */
+export async function broadcastTopUpTransaction(parameters) {
+    const { transaction } = validateTopUpCredentialTransaction(parameters);
     const receipt = await sendCredentialTransaction({
         challengeExpires: parameters.challengeExpires,
         chainId: parameters.chainId,
         client: parameters.client,
-        allowedFeeTokens: [parameters.expectedCurrency],
+        allowedFeeTokens: parameters.allowedFeeTokens ?? [parameters.expectedCurrency],
         details: {
             additionalDeposit: parameters.additionalDeposit.toString(),
             channelId: parameters.expectedChannelId,
@@ -583,13 +673,24 @@ function descriptorTuple(descriptor) {
 }
 async function sendPrecompileTransaction(client, to, data, label, options) {
     const account = options?.account ?? client.account;
-    const selfSponsored = account && options?.feePayer && isAddressEqual(account.address, options.feePayer.address);
-    if (options?.feePayer && !selfSponsored) {
+    const feePayer = options?.feePayer;
+    const selfSponsored = account && typeof feePayer === 'object' && isAddressEqual(account.address, feePayer.address);
+    if (feePayer === true) {
+        if (!account)
+            throw new Error(`Cannot ${label} precompile channel: no account available.`);
+        return sendPrecompileContractCall(client, {
+            account,
+            data,
+            feePayer: true,
+            to,
+        });
+    }
+    if (feePayer && !selfSponsored) {
         if (!account)
             throw new Error(`Cannot ${label} precompile channel: no account available.`);
         const feeToken = options.feeToken ??
             (await resolveFeeToken({
-                account: options.feePayer.address,
+                account: feePayer.address,
                 candidateTokens: options.candidateFeeTokens,
                 client,
             }));
@@ -603,7 +704,7 @@ async function sendPrecompileTransaction(client, to, data, label, options) {
         const serialized = await signTempoTransaction(client, {
             ...prepared,
             account,
-            feePayer: options.feePayer,
+            feePayer,
         });
         const receipt = await sendRawTransactionSync(client, {
             serializedTransaction: serialized,

package/dist/tempo/session/precompile/Protocol.d.ts

@@ -6,6 +6,8 @@ export type Uint96 = bigint;
 export type RawAmountString = string;
 /** Returns whether a bigint can be encoded as a TIP20EscrowChannel `uint96` amount. */
 export declare function isUint96(value: bigint): value is Uint96;
+/** Parses an unsigned decimal raw amount when it fits TIP-1034's `uint96` range. */
+export declare function parseUint96Amount(value: RawAmountString): Uint96 | undefined;
 /** Converts a bigint into a TIP20EscrowChannel `uint96` amount after validating bounds. */
 export declare function uint96(value: bigint): Uint96;
 /** Asserts that a bigint can be encoded as a TIP20EscrowChannel `uint96` amount. */
@@ -55,6 +57,8 @@ export type OpenCredentialPayload = {
     transaction: Hex;
     /** Voucher signature for `cumulativeAmount`. */
     signature: Hex;
+    /** Machine-token-only router-domain guard for `cumulativeAmount`. */
+    authorizationSignature?: Hex | undefined;
     /** Descriptor needed to recover and verify the channel. */
     descriptor: ChannelDescriptor;
     /** Initial cumulative spend authorized by the opening voucher, as raw units. */
@@ -90,6 +94,8 @@ export type VoucherCredentialPayload = {
     cumulativeAmount: RawAmountString;
     /** Voucher signature for `cumulativeAmount`. */
     signature: Hex;
+    /** Machine-token-only router-domain guard for `cumulativeAmount`. */
+    authorizationSignature?: Hex | undefined;
 };
 /**
  * Credential payload that cooperatively closes a channel at final cumulative spend.
@@ -104,6 +110,13 @@ export type CloseCredentialPayload = {
     cumulativeAmount: RawAmountString;
     /** Voucher signature for `cumulativeAmount`. */
     signature: Hex;
+    /** Machine-token-only router-domain guard for `cumulativeAmount`. */
+    authorizationSignature?: Hex | undefined;
+    /**
+     * Machine-token-only signature for the full on-chain deposit. It lets the trusted router
+     * return policy-restricted principal without increasing the merchant's authorized capture.
+     */
+    refundSignature?: Hex | undefined;
 };
 /**
  * TIP20EscrowChannel precompile session credential payload (discriminated union).
@@ -122,6 +135,8 @@ export interface SessionVoucher {
  */
 export interface SessionSignedVoucher extends SessionVoucher {
     signature: Hex;
+    /** Router-domain guard retained for scheduled machine-token settlement. */
+    authorizationSignature?: Hex | undefined;
 }
 /**
  * Management action names shared by session credential payloads.

package/dist/tempo/session/precompile/Protocol.js

@@ -4,6 +4,13 @@ const maxUint96 = (1n << 96n) - 1n;
 export function isUint96(value) {
     return value >= 0n && value <= maxUint96;
 }
+/** Parses an unsigned decimal raw amount when it fits TIP-1034's `uint96` range. */
+export function parseUint96Amount(value) {
+    if (!/^\d{1,29}$/.test(value))
+        return undefined;
+    const amount = BigInt(value);
+    return isUint96(amount) ? amount : undefined;
+}
 /** Converts a bigint into a TIP20EscrowChannel `uint96` amount after validating bounds. */
 export function uint96(value) {
     assertUint96(value);

package/dist/tempo/session/precompile/Voucher.d.ts

@@ -15,11 +15,11 @@ export declare function getVoucherDomain(escrowContract: Address, chainId: numbe
  */
 export declare const voucherTypes: {
     readonly Voucher: readonly [{
-        readonly name: "channelId";
-        readonly type: "bytes32";
+        readonly name: 'channelId';
+        readonly type: 'bytes32';
     }, {
-        readonly name: "cumulativeAmount";
-        readonly type: "uint96";
+        readonly name: 'cumulativeAmount';
+        readonly type: 'uint96';
     }];
 };
 /**
@@ -36,5 +36,7 @@ export declare function verifyVoucher(escrowContract: Address, chainId: number,
 /**
  * Parse a voucher from credential payload.
  */
-export declare function parseVoucherFromPayload(channelId: Hex, cumulativeAmount: string, signature: Hex): SignedVoucher;
+export declare function parseVoucherFromPayload(channelId: Hex, cumulativeAmount: string, signature: Hex, authorizationSignature?: Hex | undefined): SignedVoucher & {
+    authorizationSignature?: Hex | undefined;
+};
 //# sourceMappingURL=Voucher.d.ts.map

package/dist/tempo/session/precompile/Voucher.js

@@ -3,6 +3,7 @@ import { hashTypedData } from 'viem';
 import { signTypedData } from 'viem/actions';
 import { Account as TempoAccount } from 'viem/tempo';
 import * as TempoAddress from '../../internal/address.js';
+import { parseCanonicalEnvelope, serializeCanonicalEnvelope, } from '../../internal/signature-envelope.js';
 import { uint96 } from './Protocol.js';
 /** Must match the on-chain TIP-20 channel reserve DOMAIN_SEPARATOR name. */
 const DOMAIN_NAME = 'TIP20 Channel Reserve';
@@ -49,9 +50,6 @@ function getVoucherPayload(verifyingContract, chainId, voucher) {
         },
     });
 }
-function isPrimitiveEnvelope(type) {
-    return type === 'secp256k1' || type === 'p256' || type === 'webAuthn';
-}
 function signCanonicalTempoVoucher(account, parameters) {
     // viem/tempo's canonical TIP-1034 voucher signer accepts Tempo account
     // extensions that are wider than viem's base Account type. Keep that
@@ -85,10 +83,7 @@ export async function signVoucher(client, account, voucher, verifyingContract, c
             message: voucher,
         });
     })();
-    const envelope = SignatureEnvelope.from(signature);
-    if (!isPrimitiveEnvelope(envelope.type))
-        throw new Error(`TIP-1034 vouchers require a TIP-1020 primitive signature; received "${envelope.type}".`);
-    return SignatureEnvelope.serialize(envelope);
+    return serializeCanonicalEnvelope(signature, 'TIP-1034 vouchers');
 }
 /**
  * Verify a voucher signature matches the expected signer.
@@ -98,10 +93,8 @@ export async function signVoucher(client, account, voucher, verifyingContract, c
  */
 export function verifyVoucher(escrowContract, chainId, voucher, expectedSigner) {
     try {
-        const envelope = SignatureEnvelope.from(voucher.signature);
-        if (!isPrimitiveEnvelope(envelope.type))
-            return false;
-        if (SignatureEnvelope.serialize(envelope).toLowerCase() !== voucher.signature.toLowerCase())
+        const envelope = parseCanonicalEnvelope(voucher.signature);
+        if (!envelope)
             return false;
         const payload = getVoucherPayload(escrowContract, chainId, voucher);
         const signer = SignatureEnvelope.extractAddress({ payload, signature: envelope });
@@ -115,11 +108,12 @@ export function verifyVoucher(escrowContract, chainId, voucher, expectedSigner)
 /**
  * Parse a voucher from credential payload.
  */
-export function parseVoucherFromPayload(channelId, cumulativeAmount, signature) {
+export function parseVoucherFromPayload(channelId, cumulativeAmount, signature, authorizationSignature) {
     return {
         channelId,
         cumulativeAmount: uint96(BigInt(cumulativeAmount)),
         signature,
+        ...(authorizationSignature ? { authorizationSignature } : {}),
     };
 }
 //# sourceMappingURL=Voucher.js.map