mppx 0.8.17 → 0.8.18

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

@@ -177,8 +177,8 @@ 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. */
@@ -197,6 +197,8 @@ export declare function simulateCredentialTransaction(parameters: {
  * 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.
  */
@@ -213,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: {
@@ -279,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. */
@@ -334,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. */

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))
@@ -322,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 } : {}),
     });
 }
@@ -340,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.
  */
@@ -371,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.
  */
@@ -488,7 +517,7 @@ export function validateOpenCredentialTransaction(parameters) {
     if (parameters.feePayer)
         assertSenderSigned(transaction);
     validateCredentialSponsorship({
-        allowedFeeTokens: [parameters.expectedCurrency],
+        allowedFeeTokens: parameters.allowedFeeTokens ?? [parameters.expectedCurrency],
         challengeExpires: parameters.challengeExpires,
         chainId: parameters.chainId,
         details: {
@@ -522,7 +551,7 @@ export async function broadcastOpenTransaction(parameters) {
         challengeExpires: parameters.challengeExpires,
         chainId: parameters.chainId,
         client: parameters.client,
-        allowedFeeTokens: [parameters.expectedCurrency],
+        allowedFeeTokens: parameters.allowedFeeTokens ?? [parameters.expectedCurrency],
         details: {
             channelId: parameters.expectedChannelId,
             currency: parameters.expectedCurrency,
@@ -580,7 +609,7 @@ export function validateTopUpCredentialTransaction(parameters) {
     if (parameters.feePayer)
         assertSenderSigned(transaction);
     validateCredentialSponsorship({
-        allowedFeeTokens: [parameters.expectedCurrency],
+        allowedFeeTokens: parameters.allowedFeeTokens ?? [parameters.expectedCurrency],
         challengeExpires: parameters.challengeExpires,
         chainId: parameters.chainId,
         details: {
@@ -601,7 +630,7 @@ export async function broadcastTopUpTransaction(parameters) {
         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,
@@ -644,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,
             }));
@@ -664,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

@@ -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

package/dist/tempo/session/server/ChannelStore.d.ts

@@ -54,6 +54,8 @@ export type HighestVoucherParameters = {
     cumulativeAmount: bigint;
     /** Candidate voucher signature. */
     signature: Hex;
+    /** Optional router-domain authorization retained for machine-token settlement. */
+    authorizationSignature?: Hex | undefined;
 };
 /** Highest accepted voucher amount plus signed voucher payload. */
 export type HighestVoucher = {
@@ -93,6 +95,8 @@ export type OpenChannelStateParameters = {
     cumulativeAmount: bigint;
     /** Voucher signature for `cumulativeAmount`. */
     signature: Hex;
+    /** Optional router-domain authorization for the initial machine-token voucher. */
+    authorizationSignature?: Hex | undefined;
     /** Latest on-chain channel state read after open. */
     state: Chain.ChannelState;
 };
@@ -134,6 +138,8 @@ export type PendingCloseUpdate = {
 };
 /** Inputs for finalizing local state after a successful close transaction. */
 export type FinalizeClosedChannelParameters = {
+    /** Router authorization paired with the close voucher on machine channels. */
+    authorizationSignature?: Hex | undefined;
     /** Amount captured to payee during close. */
     captureAmount: bigint;
     /** Normalized channel ID. */

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

@@ -25,7 +25,7 @@ export function mergeActiveOnChainState(current, state) {
 }
 /** Keeps the existing higher voucher, otherwise stores the supplied candidate voucher. */
 export function resolveHighestVoucher(parameters) {
-    const { channelId, current, cumulativeAmount, signature } = parameters;
+    const { authorizationSignature, channelId, current, cumulativeAmount, signature } = parameters;
     if (current?.highestVoucherAmount && current.highestVoucherAmount > cumulativeAmount) {
         return {
             highestVoucherAmount: current.highestVoucherAmount,
@@ -34,7 +34,12 @@ export function resolveHighestVoucher(parameters) {
     }
     return {
         highestVoucherAmount: cumulativeAmount,
-        highestVoucher: { channelId, cumulativeAmount, signature },
+        highestVoucher: {
+            channelId,
+            cumulativeAmount,
+            signature,
+            ...(authorizationSignature ? { authorizationSignature } : {}),
+        },
     };
 }
 /** Derives persisted identity fields from a verified precompile channel descriptor. */
@@ -59,8 +64,9 @@ export function resolvePrecompileChannelIdentity(parameters) {
 export function openChannelState(parameters) {
     const { authorizedSigner, chainId, channelId, current, descriptor, escrow, expiringNonceHash } = parameters;
     const { state } = parameters;
-    const { cumulativeAmount, signature } = parameters;
+    const { authorizationSignature, cumulativeAmount, signature } = parameters;
     const highestVoucher = resolveHighestVoucher({
+        authorizationSignature,
         channelId,
         current,
         cumulativeAmount,
@@ -164,10 +170,11 @@ export function markPendingClose(parameters) {
 }
 /** Finalizes local channel state after a successful close transaction. */
 export function finalizeClosedChannelState(parameters) {
-    const { captureAmount, channelId, cumulativeAmount, current, signature } = parameters;
+    const { authorizationSignature, captureAmount, channelId, cumulativeAmount, current, signature } = parameters;
     if (!current)
         return current;
     const highestVoucher = resolveHighestVoucher({
+        authorizationSignature,
         channelId,
         current,
         cumulativeAmount,

package/dist/tempo/session/server/CredentialVerification.d.ts

@@ -5,21 +5,22 @@ import * as Chain from '../precompile/Chain.js';
 import * as Channel from '../precompile/Channel.js';
 import { type SessionCredentialPayload, type SessionReceipt } from '../precompile/Protocol.js';
 import * as ChannelStore from './ChannelStore.js';
+import { type ChallengePaymentFields } from './RequestState.js';
 import { type OnSessionSettlement } from './Settlement.js';
 /** Returns the effective voucher signer for a TIP-1034 descriptor. */
 export declare function authorizedSigner(descriptor: Channel.ChannelDescriptor): Address;
-/** Asserts that a credential payload includes a TIP-1034 descriptor. */
-export declare function assertDescriptor(payload: {
-    descriptor?: Channel.ChannelDescriptor | undefined;
-}): asserts payload is {
-    descriptor: Channel.ChannelDescriptor;
-};
 /** Asserts that two TIP-1034 descriptors identify the same channel. */
 export declare function assertSameDescriptor(a: Channel.ChannelDescriptor, b: Channel.ChannelDescriptor): void;
 /**
  * Validates a TIP-1034 descriptor against channel ID, server destination, and token.
  */
 export declare function validateChannelDescriptor(descriptor: Channel.ChannelDescriptor, channelId: Address | `0x${string}`, chainId: number, escrow: Address, recipient: Address, currency: Address, expectedOperator?: Address | undefined): void;
+type ResolvedCredentialRoute = {
+    allowedFeeTokens: readonly Address[];
+    expectedOperator: Address;
+    machineRouter?: Address | undefined;
+    payment: ChallengePaymentFields;
+};
 /** Validates on-chain channel state before accepting or charging a credential. */
 export declare function validateChannelState(state: Chain.ChannelState, amount?: bigint): void;
 /** Asserts that an opening channel covers the route's requested payment. */
@@ -69,7 +70,7 @@ export type BroadcastCredentialPayloadParameters = {
     feePayer?: viem_Account | true | undefined;
     /** Optional policy for fee-sponsored close/open/top-up transactions. */
     feePayerPolicy?: Partial<FeePayer.Policy> | undefined;
-    /** Optional fee token override for close transactions. */
+    /** Optional fee token override for sponsored management and settlement transactions. */
     feeToken?: Address | undefined;
     /** Last successful on-chain refresh timestamp per channel ID. */
     lastOnChainVerified: Map<Hex, number>;
@@ -85,7 +86,7 @@ export type BroadcastCredentialPayloadParameters = {
 /** @deprecated Use {@link BroadcastCredentialPayloadParameters}. */
 export type VerifyCredentialPayloadParameters = BroadcastCredentialPayloadParameters;
 /** Narrows shared credential broadcast inputs to one payload action. */
-export type BroadcastCredentialActionParameters<action extends SessionCredentialPayload['action']> = Omit<BroadcastCredentialPayloadParameters, 'payload'> & {
+export type BroadcastCredentialActionParameters<action extends SessionCredentialPayload['action']> = Omit<BroadcastCredentialPayloadParameters, 'payload'> & ResolvedCredentialRoute & {
     /** Credential payload for the selected action. */
     payload: Extract<SessionCredentialPayload, {
         action: action;
@@ -102,7 +103,7 @@ export type VoucherCredentialActionParameters = BroadcastCredentialActionParamet
 /** Inputs for broadcasting and settling a cooperative close credential. */
 export type CloseCredentialActionParameters = BroadcastCredentialActionParameters<'close'>;
 /** Inputs for validating a session credential without applying its state transition. */
-export type ValidateCredentialPayloadParameters = Pick<BroadcastCredentialPayloadParameters, 'account' | 'channelStateTtl' | 'chainId' | 'client' | 'credentialSource' | 'escrow' | 'expectedOperator' | 'feePayer' | 'feePayerPolicy' | 'lastOnChainVerified' | 'minVoucherDelta' | 'payload' | 'store' | 'challenge'>;
+export type ValidateCredentialPayloadParameters = Pick<BroadcastCredentialPayloadParameters, 'account' | 'channelStateTtl' | 'chainId' | 'client' | 'credentialSource' | 'escrow' | 'expectedOperator' | 'feePayer' | 'feePayerPolicy' | 'feeToken' | 'lastOnChainVerified' | 'minVoucherDelta' | 'payload' | 'store' | 'challenge'>;
 /** Non-mutating result produced by session credential validation. */
 export type CredentialPayloadValidation = {
     /** Session action validated from the credential. */
@@ -116,4 +117,5 @@ export declare function validateCredentialPayload(parameters: ValidateCredential
 export declare function broadcastCredentialPayload(context: BroadcastCredentialPayloadParameters): Promise<SessionReceipt>;
 /** @deprecated Use {@link broadcastCredentialPayload}. */
 export declare function verifyCredentialPayload(context: VerifyCredentialPayloadParameters): Promise<SessionReceipt>;
+export {};
 //# sourceMappingURL=CredentialVerification.d.ts.map