mppx 0.8.18 → 0.9.0

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

@@ -1,4 +1,4 @@
-import { isAddressEqual, parseUnits } from 'viem';
+import { parseUnits } from 'viem';
 import { tempo as tempo_chain } from 'viem/chains';
 import * as MethodChallenge from '../../../client/internal/MethodChallenge.js';
 import * as MethodResponse from '../../../client/internal/MethodResponse.js';
@@ -9,15 +9,13 @@ import * as Account from '../../../viem/Account.js';
 import * as Client from '../../../viem/Client.js';
 import * as AutoSwap from '../../internal/auto-swap.js';
 import * as defaults from '../../internal/defaults.js';
-import * as MachineTokenSession from '../../internal/machine-token-session.js';
 import * as Methods from '../../Methods.js';
-import * as Chain from '../precompile/Chain.js';
 import * as Channel from '../precompile/Channel.js';
-import { deserializeSessionReceipt, isEventStream, readSessionChallengeAmount, requireSessionCredentialContext, tip20ChannelEscrow, } from '../precompile/Protocol.js';
-import { createVoucherPayload, serializeCredential } from './ChannelOps.js';
+import { deserializeSessionReceipt, isEventStream, readSessionChallengeAmount, requireSessionCredentialContext, } from '../precompile/Protocol.js';
+import { serializeCredential } from './ChannelOps.js';
 import { createChannelStore, entryKey } from './ChannelStore.js';
-import { canSignDescriptor, executeCredentialPlan, hasSessionAction, planCredential, requireContextAmount, resolveChallengeContext, resolveRecoverContext, sessionContextSchema, } from './CredentialState.js';
-import { assertWithinMaxDeposit, resolveAutomaticTopUp, resolveOpeningDeposit } from './Runtime.js';
+import { canSignDescriptor, executeCredentialPlan, hasSessionAction, planCredential, resolveChallengeContext, resolveRecoverContext, sessionContextSchema, } from './CredentialState.js';
+import { assertWithinMaxDeposit, resolveAutomaticTopUp } from './Runtime.js';
 import { getSessionSnapshot, handleSseNeedVoucher, isTip1034SessionChallenge, postTopUp, wrapSseResponse, } from './Transports.js';
 export { sessionContextSchema } from './CredentialState.js';
 /** Tail promise for each payment scope, used to serialize automatic opens per store. */
@@ -71,42 +69,6 @@ function acknowledgesOpen(outcome, challenge, opened) {
         return matchesOpen(opened, getSessionSnapshot(candidate));
     }) ?? false);
 }
-function applyMachineTokenRoute(resolved, route) {
-    const snapshotDescriptor = resolved.snapshot?.descriptor;
-    const snapshotMatches = snapshotDescriptor &&
-        isAddressEqual(snapshotDescriptor.payee, route.payee) &&
-        isAddressEqual(snapshotDescriptor.operator, route.operator) &&
-        isAddressEqual(snapshotDescriptor.token, route.token);
-    return {
-        ...resolved,
-        operator: route.operator,
-        payee: route.payee,
-        paymentScope: { payee: resolved.payee, token: resolved.token },
-        snapshot: snapshotMatches ? resolved.snapshot : undefined,
-        token: route.token,
-    };
-}
-async function resolveMachineContext(resolved, context) {
-    const descriptor = context?.descriptor ?? resolved.snapshot?.descriptor;
-    if (!descriptor)
-        return undefined;
-    if (!MachineTokenSession.matchDeployment({ chainId: resolved.chainId, descriptor }))
-        return undefined;
-    const closing = context?.action === 'close';
-    if ((!closing && !MachineTokenSession.isEnabledChallenge(resolved.challenge)) ||
-        !isAddressEqual(resolved.escrow, tip20ChannelEscrow))
-        return undefined;
-    const route = await MachineTokenSession.matchRoute(resolved.client, {
-        active: !closing,
-        chainId: resolved.chainId,
-        descriptor,
-        merchant: resolved.payee,
-        targetToken: resolved.token,
-    });
-    if (!route)
-        throw new Error('Machine-token channel is not bound to this merchant session challenge.');
-    return applyMachineTokenRoute(resolved, route);
-}
 /**
  * Creates the low-level TIP-1034 session payment method for use with `Mppx.create()`.
  *
@@ -125,15 +87,7 @@ export function session(parameters = {}) {
     const maxDeposit = maxDepositParameter !== undefined ? parseUnits(maxDepositParameter, decimals) : undefined;
     const topUpAmount = topUpAmountParameter !== undefined ? parseUnits(topUpAmountParameter, decimals) : undefined;
     const store = channelStore ?? createChannelStore();
-    const commitEntry = async (entry) => {
-        if (!entry)
-            return;
-        if (entry.opened)
-            await store.set(entry);
-        else
-            await store.delete(entryKey(entry));
-        onChannelUpdate?.(entry);
-    };
+    const sink = { store, notifyUpdate: (entry) => onChannelUpdate?.(entry) };
     const resolveCredentialAccount = async (resolved, context, entry) => {
         const defaultAccount = getAccount(resolved.client, context);
         const descriptor = context?.action
@@ -149,132 +103,67 @@ export function session(parameters = {}) {
             },
         })) ?? defaultAccount);
     };
-    const resolveContext = (challenge) => resolveChallengeContext({
-        allowCustomEscrow,
-        challenge,
-        escrowOverride,
-        getClient,
+    const resolveCredentialPlan = async (resolved, context, entry) => planCredential({
+        account: await resolveCredentialAccount(resolved, context, entry),
+        entry,
+        context,
+        decimals,
+        maxDeposit,
+        resolved,
     });
-    /** Selects one rail for this channel lifecycle before any credential is signed. */
-    const resolveRail = async (direct, context) => {
-        let account;
-        const descriptor = context?.descriptor ?? direct.snapshot?.descriptor;
-        if (descriptor || hasSessionAction(context)) {
-            const machine = descriptor ? await resolveMachineContext(direct, context) : undefined;
-            const resolved = machine ?? direct;
-            return {
-                account,
-                entry: await store.get(resolved.key),
-                machine: machine !== undefined,
-                resolved,
-            };
-        }
-        const directEntry = await store.get(direct.key);
-        if (directEntry?.opened) {
-            if (!MachineTokenSession.matchDeployment({
-                chainId: direct.chainId,
-                descriptor: directEntry.descriptor,
-            }))
-                return { account, entry: directEntry, machine: false, resolved: direct };
-            const machine = await resolveMachineContext(direct, { descriptor: directEntry.descriptor });
-            if (!machine)
-                throw new Error('Machine-token channel is not bound to this merchant session challenge.');
-            return { account, entry: directEntry, machine: true, resolved: machine };
-        }
-        if (!MachineTokenSession.isEnabledChallenge(direct.challenge) ||
-            !isAddressEqual(direct.escrow, tip20ChannelEscrow))
-            return { account, entry: undefined, machine: false, resolved: direct };
-        const route = await MachineTokenSession.resolveRoute(direct.client, {
-            chainId: direct.chainId,
-            merchant: direct.payee,
-            targetToken: direct.token,
-        }).catch(() => undefined);
-        if (!route)
-            return { account, entry: undefined, machine: false, resolved: direct };
-        const machine = applyMachineTokenRoute(direct, route);
-        account = await resolveCredentialAccount(machine, context, undefined);
-        const openingDeposit = resolveOpeningDeposit({
-            contextDepositRaw: context?.depositRaw,
-            maxDeposit,
-            requestAmount: direct.amount,
-            suggestedDepositRaw: direct.suggestedDepositRaw,
-        });
-        const funded = await MachineTokenSession.hasSufficientBalance(machine.client, {
-            account: account.address,
-            amount: openingDeposit,
-            token: machine.token,
-        });
-        return funded
-            ? { account, entry: undefined, machine: true, resolved: machine }
-            : { account, entry: undefined, machine: false, resolved: direct };
-    };
     const method = Method.toClient(Methods.session, {
         canHandleChallenge: ({ challenge }) => isTip1034SessionChallenge(challenge),
         context: sessionContextSchema,
         async createCredential(parameters) {
             const { challenge, context } = parameters;
+            const resolved = await resolveChallengeContext({
+                allowCustomEscrow,
+                challenge,
+                escrowOverride,
+                getClient,
+            });
             const attempt = MethodResponse.getAttempt(parameters);
             let release = () => { };
             try {
-                const direct = await resolveContext(challenge);
-                if (!hasSessionAction(context) && context?.descriptor === undefined) {
-                    release = await lockChannel(store, direct.key);
-                    if (attempt && (await store.get(direct.key))?.opened)
+                const automatic = !hasSessionAction(context) && context?.descriptor === undefined;
+                if (automatic) {
+                    release = await lockChannel(store, resolved.key);
+                    if (attempt && (await store.get(resolved.key))?.opened)
                         await attempt.prepare();
                 }
-                const { account, entry, machine, resolved } = await resolveRail(direct, context);
-                const credentialAccount = account ?? (await resolveCredentialAccount(resolved, context, entry));
-                const plan = planCredential({
-                    account: credentialAccount,
-                    entry,
-                    context,
-                    decimals,
-                    maxDeposit,
-                    resolved,
-                });
-                if (machine && plan.type === 'manual' && plan.context.action === 'topUp') {
-                    const additionalDeposit = requireContextAmount(plan.context, plan.decimals, 'additionalDeposit', 'topUp');
-                    if (!(await MachineTokenSession.hasSufficientBalance(plan.resolved.client, {
-                        account: plan.account.address,
-                        amount: additionalDeposit,
-                        token: plan.resolved.token,
-                    })))
-                        throw new Error('Insufficient machine-token balance for session top-up.');
-                }
-                const feeToken = MachineTokenSession.resolveFeeToken({
-                    chainId: resolved.chainId,
-                    override: resolved.feeToken,
-                    paymentToken: resolved.token,
-                });
-                const result = await executeCredentialPlan(plan, AutoSwap.resolve(context?.autoSwap ?? autoSwapParameter, AutoSwap.defaultCurrencies), feeToken);
-                let { payload } = result;
-                if (machine && payload.action !== 'topUp') {
-                    if (payload.action === 'close') {
-                        const state = await Chain.getChannelState(plan.resolved.client, payload.channelId, plan.resolved.escrow);
-                        if (state.deposit === 0n)
-                            throw new Error('Cannot authorize a machine-token refund for an empty channel.');
-                        // The refund authorization covers the full on-chain deposit, while
-                        // the close voucher remains the exact amount the merchant captures.
-                        const depositSignature = BigInt(payload.cumulativeAmount) === state.deposit
-                            ? payload.signature
-                            : (await createVoucherPayload(plan.resolved.client, plan.account, payload.descriptor, state.deposit, plan.resolved.chainId, plan.resolved.escrow)).signature;
-                        payload = { ...payload, refundSignature: depositSignature };
+                let entry = await store.get(resolved.key);
+                let plan = await resolveCredentialPlan(resolved, context, entry);
+                if (!automatic && attempt && plan.type === 'open') {
+                    release = await lockChannel(store, resolved.key);
+                    const nextEntry = await store.get(resolved.key);
+                    if (nextEntry?.channelId !== entry?.channelId) {
+                        entry = nextEntry;
+                        if (entry?.opened) {
+                            await attempt.prepare();
+                            entry = await store.get(resolved.key);
+                        }
+                        plan = await resolveCredentialPlan(resolved, context, entry);
                     }
-                    const authorizationSignature = await MachineTokenSession.signAuthorization(plan.resolved.client, plan.account, {
-                        authorization: {
-                            channelId: payload.channelId,
-                            cumulativeAmount: BigInt(payload.cumulativeAmount),
-                        },
-                        chainId: plan.resolved.chainId,
-                        router: plan.resolved.operator,
-                    });
-                    payload = { ...payload, authorizationSignature };
                 }
-                if (!(attempt && plan.type === 'open'))
-                    await commitEntry(result.entry);
+                let pendingOpen;
+                // Defer opens only when low-level Fetch owns the response lifecycle.
+                // SessionManager unregisters this hook and keeps its existing transaction boundary.
+                const credentialSink = attempt && plan.type === 'open'
+                    ? {
+                        store: {
+                            get: (key) => store.get(key),
+                            async set(next) {
+                                pendingOpen = next;
+                            },
+                            delete: (key) => store.delete(key),
+                        },
+                        notifyUpdate() { },
+                    }
+                    : sink;
+                const payload = await executeCredentialPlan(plan, credentialSink, AutoSwap.resolve(context?.autoSwap ?? autoSwapParameter, AutoSwap.defaultCurrencies));
                 const credential = await serializeCredential(challenge, payload, resolved.chainId, plan.account);
-                if (attempt && plan.type === 'open' && result.entry) {
-                    const opened = result.entry;
+                if (attempt && pendingOpen) {
+                    const opened = pendingOpen;
                     attempt.settle = async (outcome) => {
                         const accepted = outcome.status === 'accepted' || acknowledgesOpen(outcome, challenge, opened);
                         if (!accepted && outcome.status === 'pending')
@@ -284,7 +173,8 @@ export function session(parameters = {}) {
                                 const current = await store.get(resolved.key);
                                 if (!current?.opened ||
                                     current.channelId.toLowerCase() !== opened.channelId.toLowerCase()) {
-                                    await commitEntry(opened);
+                                    await store.set(opened);
+                                    sink.notifyUpdate(opened);
                                 }
                             }
                             return true;
@@ -335,7 +225,7 @@ export function session(parameters = {}) {
             deposit: latest.deposit > nextDeposit ? latest.deposit : nextDeposit,
         };
         await store.set(updated);
-        onChannelUpdate?.(updated);
+        sink.notifyUpdate(updated);
     };
     MethodChallenge.register(method, async ({ challenge, context, fetch, input }) => {
         if (!isTip1034SessionChallenge(challenge))
@@ -343,11 +233,13 @@ export function session(parameters = {}) {
         const sessionContext = context === undefined ? undefined : sessionContextSchema.parse(context);
         if (hasSessionAction(sessionContext))
             return;
-        const direct = await resolveContext(challenge);
-        const { entry: channel, resolved } = await resolveRail(direct, sessionContext).catch(() => ({
-            entry: undefined,
-            resolved: direct,
-        }));
+        const resolved = await resolveChallengeContext({
+            allowCustomEscrow,
+            challenge,
+            escrowOverride,
+            getClient,
+        });
+        const channel = await store.get(resolved.key);
         if (!channel?.opened)
             return;
         const snapshot = resolved.snapshot?.channelId.toLowerCase() === channel.channelId.toLowerCase()
@@ -375,17 +267,20 @@ export function session(parameters = {}) {
     return MethodResponse.register(method, async ({ challenge, credential, fetch, headers, input, refetch, response, signal }) => {
         if (!isTip1034SessionChallenge(challenge))
             return response;
-        const credentialContext = requireSessionCredentialContext(Credential.deserialize(credential).payload);
         if (!isEventStream(response)) {
+            const credentialContext = requireSessionCredentialContext(Credential.deserialize(credential).payload);
             if (credentialContext.action === 'open' &&
                 headers.get('accept')?.toLowerCase().includes('text/event-stream'))
                 return (await refetch?.()) ?? response;
             return response;
         }
-        const resolvedContext = await resolveContext(challenge)
-            .then(async (direct) => (await resolveMachineContext(direct, credentialContext)) ?? direct)
-            .catch(() => undefined);
-        const channel = resolvedContext ? await store.get(resolvedContext.key) : undefined;
+        const channelKey = (await resolveChallengeContext({
+            allowCustomEscrow,
+            challenge,
+            escrowOverride,
+            getClient,
+        })).key;
+        let channel = await store.get(channelKey);
         const driver = {
             assertVoucherWithinLocalLimit: (cumulativeAmount) => assertWithinMaxDeposit(cumulativeAmount, maxDeposit),
             createSessionCredential: (challenge, context) => method.createCredential({ challenge, context }),

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

@@ -9,7 +9,6 @@ import * as Account from '../../../viem/Account.js';
 import * as Client from '../../../viem/Client.js';
 import { charge as chargePlugin } from '../../client/Charge.js';
 import * as defaults from '../../internal/defaults.js';
-import { hasRewrittenScope, isMachineChannel } from '../client/ChannelOps.js';
 import { createChannelStore, entryKey } from '../client/ChannelStore.js';
 import { hydrateSessionSnapshot } from '../client/CredentialState.js';
 import { session as sessionPlugin } from '../client/Session.js';
@@ -274,7 +273,7 @@ export function sessionManager(parameters) {
         });
     }
     /** Persists a server snapshot into the channel store and returns the entry. */
-    async function storeSnapshotHeader(response, paymentScope) {
+    async function storeSnapshotHeader(response) {
         const header = response.headers.get(Constants.Headers.paymentSessionSnapshot);
         if (!header)
             return undefined;
@@ -289,14 +288,11 @@ export function sessionManager(parameters) {
                 kind: 'authorizePaymentChannel',
             },
         })) ?? defaultAccount;
-        const hydrated = await hydrateSessionSnapshot({ account, client, snapshot });
-        const entry = paymentScope && hasRewrittenScope({ descriptor: hydrated.entry.descriptor, paymentScope })
-            ? { ...hydrated.entry, paymentScope }
-            : hydrated.entry;
+        const { entry, spent } = await hydrateSessionSnapshot({ account, client, snapshot });
         assertVoucherWithinLocalLimit(entry.cumulativeAmount);
         await Promise.resolve(store.set(entry)).catch(() => undefined);
         runtime.channel = entry;
-        runtime.spent = hydrated.spent;
+        runtime.spent = spent;
         return entry;
     }
     async function bootstrapSession(input, init) {
@@ -337,10 +333,7 @@ export function sessionManager(parameters) {
                 },
             });
             if (response.ok)
-                return await storeSnapshotHeader(response, {
-                    payee: challenge.request.recipient,
-                    token: challenge.request.currency,
-                });
+                return await storeSnapshotHeader(response);
             return undefined;
         }
         catch {
@@ -381,9 +374,8 @@ export function sessionManager(parameters) {
             throw new Error('close snapshot payment scope does not match local session');
         }
         const acceptedCumulative = BigInt(snapshot.acceptedCumulative);
-        const settled = BigInt(snapshot.settled);
         const snapshotSpent = BigInt(snapshot.spent);
-        if (acceptedCumulative < 0n || settled < 0n || snapshotSpent < 0n) {
+        if (acceptedCumulative < 0n || snapshotSpent < 0n) {
             throw new Error('close snapshot amounts must not be negative');
         }
         if (snapshotSpent > acceptedCumulative) {
@@ -392,7 +384,7 @@ export function sessionManager(parameters) {
         if (acceptedCumulative > channel.cumulativeAmount) {
             throw new Error('close snapshot accepted cumulative exceeds local voucher state');
         }
-        return { acceptedCumulative, settled, spent: snapshotSpent };
+        return { acceptedCumulative, spent: snapshotSpent };
     }
     function applyCloseSnapshot(target, challenge) {
         const snapshot = validateCloseSnapshot(target.channel, challenge);
@@ -410,14 +402,7 @@ export function sessionManager(parameters) {
         const snapshot = applySnapshot
             ? applyCloseSnapshot(target, challenge)
             : validateCloseSnapshot(target.channel, challenge);
-        const machineSession = isMachineChannel(target.channel);
-        const closeAmount = snapshot
-            ? machineSession
-                ? snapshot.spent > snapshot.settled
-                    ? snapshot.spent
-                    : snapshot.settled
-                : snapshot.acceptedCumulative
-            : getFallbackCloseAmount(challenge, target.channelId);
+        const closeAmount = snapshot?.acceptedCumulative ?? getFallbackCloseAmount(challenge, target.channelId);
         if (closeAmount > target.channel.cumulativeAmount) {
             throw new Error('fallback close amount exceeds local voucher state');
         }
@@ -545,10 +530,11 @@ export function sessionManager(parameters) {
             trackCreates: false,
         };
         channelUse = use;
+        // Cold starts resume from `channelStore` after the 402 reveals the scope.
+        const liveHint = runtime.channel?.opened ? runtime.channel.channelId : undefined;
         try {
             await bootstrapSession(input, init);
             use.trackCreates = true;
-            const liveHint = runtime.channel?.opened ? runtime.channel.channelId : undefined;
             let effectiveInit = requestInitWithSessionHint(input, init, liveHint);
             // Stored channels may be stale, so retry once after evicting the resumed entry.
             let canRetryResumed = !previous.channel?.opened;
@@ -556,11 +542,6 @@ export function sessionManager(parameters) {
                 const resumed = use.resumed;
                 if (!canRetryResumed || !resumed)
                     return false;
-                // A machine-token entry holds the only local copy of its channel
-                // descriptor; evicting it would strand the deposit, so fail loudly
-                // instead of retrying without it.
-                if (resumed.opened && (isMachineChannel(resumed) || hasRewrittenScope(resumed)))
-                    return false;
                 canRetryResumed = false;
                 await ignoreChannel(resumed);
                 effectiveInit = requestInitWithSessionHint(input, init, undefined);

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

@@ -197,8 +197,6 @@ 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.
  */
@@ -215,8 +213,6 @@ 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: {

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

@@ -1,4 +1,4 @@
-import { decodeFunctionData, encodeFunctionData, isAddressEqual, parseAbi, parseEventLogs, } from 'viem';
+import { decodeFunctionData, encodeFunctionData, isAddressEqual, 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,10 +8,6 @@ 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))
@@ -345,26 +341,6 @@ 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.
  */
@@ -396,10 +372,6 @@ 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.
  */
@@ -682,6 +654,7 @@ async function sendPrecompileTransaction(client, to, data, label, options) {
             account,
             data,
             feePayer: true,
+            feeToken: options.feeToken,
             to,
         });
     }

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

@@ -57,8 +57,6 @@ 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. */
@@ -94,8 +92,6 @@ 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.
@@ -110,13 +106,6 @@ 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).
@@ -135,8 +124,6 @@ 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/Voucher.d.ts

@@ -36,7 +36,5 @@ export declare function verifyVoucher(escrowContract: Address, chainId: number,
 /**
  * Parse a voucher from credential payload.
  */
-export declare function parseVoucherFromPayload(channelId: Hex, cumulativeAmount: string, signature: Hex, authorizationSignature?: Hex | undefined): SignedVoucher & {
-    authorizationSignature?: Hex | undefined;
-};
+export declare function parseVoucherFromPayload(channelId: Hex, cumulativeAmount: string, signature: Hex): SignedVoucher;
 //# sourceMappingURL=Voucher.d.ts.map

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

@@ -3,7 +3,6 @@ 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';
@@ -50,6 +49,9 @@ 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
@@ -83,7 +85,10 @@ export async function signVoucher(client, account, voucher, verifyingContract, c
             message: voucher,
         });
     })();
-    return serializeCanonicalEnvelope(signature, 'TIP-1034 vouchers');
+    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);
 }
 /**
  * Verify a voucher signature matches the expected signer.
@@ -93,8 +98,10 @@ export async function signVoucher(client, account, voucher, verifyingContract, c
  */
 export function verifyVoucher(escrowContract, chainId, voucher, expectedSigner) {
     try {
-        const envelope = parseCanonicalEnvelope(voucher.signature);
-        if (!envelope)
+        const envelope = SignatureEnvelope.from(voucher.signature);
+        if (!isPrimitiveEnvelope(envelope.type))
+            return false;
+        if (SignatureEnvelope.serialize(envelope).toLowerCase() !== voucher.signature.toLowerCase())
             return false;
         const payload = getVoucherPayload(escrowContract, chainId, voucher);
         const signer = SignatureEnvelope.extractAddress({ payload, signature: envelope });
@@ -108,12 +115,11 @@ export function verifyVoucher(escrowContract, chainId, voucher, expectedSigner)
 /**
  * Parse a voucher from credential payload.
  */
-export function parseVoucherFromPayload(channelId, cumulativeAmount, signature, authorizationSignature) {
+export function parseVoucherFromPayload(channelId, cumulativeAmount, signature) {
     return {
         channelId,
         cumulativeAmount: uint96(BigInt(cumulativeAmount)),
         signature,
-        ...(authorizationSignature ? { authorizationSignature } : {}),
     };
 }
 //# sourceMappingURL=Voucher.js.map

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

@@ -54,8 +54,6 @@ 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 = {
@@ -95,8 +93,6 @@ 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;
 };
@@ -138,8 +134,6 @@ 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. */