mppx 0.8.18 → 0.9.0

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

@@ -33,11 +33,6 @@ export type ChannelEntry = {
     chainId: number;
     /** Whether the client considers the channel reusable for new vouchers. */
     opened: boolean;
-    /** Logical merchant payment scope when it differs from the on-chain descriptor. */
-    paymentScope?: {
-        payee: Address;
-        token: Address;
-    } | undefined;
 };
 /** Resolves the voucher authority address for a client account. */
 export declare function resolveAuthorizedSigner(account: Account): Address;
@@ -51,15 +46,6 @@ export declare function resolveEscrow(challenge: {
 export declare function serializeCredential(challenge: Challenge, payload: SessionCredentialPayload, chainId: number, account: Account): string;
 /** Case-insensitive EVM address equality. */
 export declare function isSameAddress(a: Address, b: Address): boolean;
-/** Returns whether a stored entry funds a machine-token session channel. */
-export declare function isMachineChannel(entry: Pick<ChannelEntry, 'chainId' | 'descriptor' | 'escrow'>): boolean;
-/**
- * Returns whether a stored entry's logical payment scope differs from its
- * on-chain descriptor. Such entries cannot be re-derived from a challenge, so
- * their descriptor is the only local copy — even when the deployment table no
- * longer recognizes the route (for example after a rotation).
- */
-export declare function hasRewrittenScope(entry: Pick<ChannelEntry, 'descriptor' | 'paymentScope'>): boolean;
 /**
  * Signs and creates a TIP-1034 voucher credential payload for an existing channel.
  *

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

@@ -13,7 +13,6 @@ import { encodeFunctionData, isAddress } from 'viem';
 import { prepareTransactionRequest, signTransaction } from 'viem/actions';
 import { Transaction } from 'viem/tempo';
 import * as Credential from '../../../Credential.js';
-import * as MachineTokenSession from '../../internal/machine-token-session.js';
 import * as Channel from '../precompile/Channel.js';
 import { escrowAbi } from '../precompile/escrow.abi.js';
 import { tip20ChannelEscrow } from '../precompile/Protocol.js';
@@ -87,27 +86,6 @@ export function serializeCredential(challenge, payload, chainId, account) {
 export function isSameAddress(a, b) {
     return a.toLowerCase() === b.toLowerCase();
 }
-/** Returns whether a stored entry funds a machine-token session channel. */
-export function isMachineChannel(entry) {
-    return (isSameAddress(entry.escrow, tip20ChannelEscrow) &&
-        MachineTokenSession.matchDeployment({
-            chainId: entry.chainId,
-            descriptor: entry.descriptor,
-        }) !== undefined);
-}
-/**
- * Returns whether a stored entry's logical payment scope differs from its
- * on-chain descriptor. Such entries cannot be re-derived from a challenge, so
- * their descriptor is the only local copy — even when the deployment table no
- * longer recognizes the route (for example after a rotation).
- */
-export function hasRewrittenScope(entry) {
-    const scope = entry.paymentScope;
-    if (!scope)
-        return false;
-    return (!isSameAddress(scope.payee, entry.descriptor.payee) ||
-        !isSameAddress(scope.token, entry.descriptor.token));
-}
 /**
  * Signs and creates a TIP-1034 voucher credential payload for an existing channel.
  *

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

@@ -10,6 +10,11 @@ export type ChannelStore = {
     /** Removes the channel cached for `key`. */
     delete(key: string): MaybePromise<void>;
 };
+/** Channel persistence and update notification for credential results. */
+export type ChannelSink = {
+    store: ChannelStore;
+    notifyUpdate: (entry: ChannelEntry) => void;
+};
 /** Returns the scope key for a reusable payer session channel. */
 export declare function channelKey(scope: {
     payee: Address;

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

@@ -6,8 +6,8 @@ export function channelKey(scope) {
 /** Returns the scope key for a stored channel entry. */
 export function entryKey(entry) {
     return channelKey({
-        payee: entry.paymentScope?.payee ?? entry.descriptor.payee,
-        token: entry.paymentScope?.token ?? entry.descriptor.token,
+        payee: entry.descriptor.payee,
+        token: entry.descriptor.token,
         escrow: entry.escrow,
         chainId: entry.chainId,
     });

package/dist/tempo/session/client/CredentialState.d.ts

@@ -8,6 +8,7 @@ import * as Channel from '../precompile/Channel.js';
 import type { SessionCredentialPayload } from '../precompile/Protocol.js';
 import type { SessionSnapshot } from '../Snapshot.js';
 import { type ChannelEntry } from './ChannelOps.js';
+import { type ChannelSink } from './ChannelStore.js';
 /** Credential payload variants that carry cumulative voucher authorization. */
 export type CumulativeCredentialPayload = Extract<SessionCredentialPayload, {
     cumulativeAmount: string;
@@ -166,11 +167,6 @@ export type ChallengeContext = {
     key: string;
     operator?: Address | undefined;
     payee: Address;
-    /** Logical merchant scope when the channel uses an indirect payment route. */
-    paymentScope?: {
-        payee: Address;
-        token: Address;
-    } | undefined;
     snapshot?: SessionSnapshot | undefined;
     /** Server-provided raw deposit hint for opening a channel, before local maxDeposit capping. */
     suggestedDepositRaw?: string | undefined;
@@ -257,14 +253,8 @@ export type CredentialPlan =
     account: ViemAccount;
     context: ManualSessionDescriptorContext;
     decimals: number;
-    entry?: ChannelEntry | undefined;
     resolved: ChallengeContext;
 };
-/** Signed credential plus the channel state to commit after all signing succeeds. */
-export type CredentialResult = {
-    payload: SessionCredentialPayload;
-    entry?: ChannelEntry | undefined;
-};
 /** Resolves raw challenge fields into the typed data required by client credential planning. */
 export declare function resolveChallengeContext(parameters: ResolveChallengeContextParameters): Promise<ChallengeContext>;
 /** Validates descriptor identity and reads open channel state for client-side recovery. */
@@ -280,5 +270,5 @@ export declare function canSignDescriptor(account: ViemAccount, descriptor: Chan
 /** Chooses the next credential plan from local channel cache and optional caller context. */
 export declare function planCredential(parameters: PlanCredentialParameters): CredentialPlan;
 /** Executes a credential plan and returns the concrete session credential payload. */
-export declare function executeCredentialPlan(plan: CredentialPlan, autoSwap?: AutoSwap.resolve.Resolved | false, feeToken?: Address | undefined): Promise<CredentialResult>;
+export declare function executeCredentialPlan(plan: CredentialPlan, sink: ChannelSink, autoSwap?: AutoSwap.resolve.Resolved | false): Promise<SessionCredentialPayload>;
 //# sourceMappingURL=CredentialState.d.ts.map

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

@@ -6,7 +6,7 @@ import * as Chain from '../precompile/Chain.js';
 import * as Channel from '../precompile/Channel.js';
 import * as Voucher from '../precompile/Voucher.js';
 import { createClosePayload, createOpenPayload, createTopUpPayload, createVoucherPayload, isSameAddress, resolveAuthorizedSigner, resolveEscrow, } from './ChannelOps.js';
-import { channelKey } from './ChannelStore.js';
+import { channelKey, entryKey } from './ChannelStore.js';
 import { assertWithinMaxDeposit, resolveOpeningDeposit } from './Runtime.js';
 /** Returns whether a credential payload carries cumulative voucher authorization. */
 export function hasCredentialCumulativeAmount(payload) {
@@ -18,18 +18,33 @@ export function readCredentialCumulativeAmount(payload) {
         return undefined;
     return BigInt(payload.cumulativeAmount);
 }
-/** Applies a credential payload to a matching cached channel without persisting it. */
-function applyCredential(entry, payload) {
+/**
+ * Persists a channel entry through the sink and notifies observers. Closed
+ * channels are removed from the store but still reported to observers so callers
+ * can react to the close.
+ */
+async function storeChannelEntry(sink, entry) {
+    if (entry.opened)
+        await sink.store.set(entry);
+    else
+        await sink.store.delete(entryKey(entry));
+    sink.notifyUpdate(entry);
+}
+/** Applies a credential payload's cumulative amount to the stored channel at `key`. */
+async function applyCumulative(sink, key, payload) {
     const cumulativeAmount = readCredentialCumulativeAmount(payload);
-    if (cumulativeAmount === undefined ||
-        !entry ||
-        entry.channelId.toLowerCase() !== payload.channelId.toLowerCase())
-        return undefined;
-    return {
-        ...entry,
-        cumulativeAmount: entry.cumulativeAmount > cumulativeAmount ? entry.cumulativeAmount : cumulativeAmount,
-        opened: payload.action === 'close' ? false : entry.opened,
-    };
+    if (cumulativeAmount === undefined)
+        return;
+    const entry = await sink.store.get(key);
+    if (!entry)
+        return;
+    if (entry.channelId.toLowerCase() !== payload.channelId.toLowerCase())
+        return;
+    entry.cumulativeAmount =
+        entry.cumulativeAmount > cumulativeAmount ? entry.cumulativeAmount : cumulativeAmount;
+    if (payload.action === 'close')
+        entry.opened = false;
+    await storeChannelEntry(sink, entry);
 }
 const hexSchema = z.custom((value) => typeof value === 'string' && /^0x[0-9a-fA-F]*$/.test(value));
 const hashSchema = z.custom((value) => typeof value === 'string' && /^0x[0-9a-fA-F]{64}$/.test(value));
@@ -275,7 +290,6 @@ export function planCredential(parameters) {
             account,
             context,
             decimals,
-            entry,
             resolved,
         };
     }
@@ -283,39 +297,30 @@ export function planCredential(parameters) {
         throw new Error('descriptor required to reuse TIP-1034 channel');
     const recoverContext = resolveRecoverContext({ context, snapshot: resolved.snapshot });
     if (!entry && recoverContext && canSignDescriptor(account, recoverContext.descriptor)) {
-        // A server snapshot may describe another rail's channel (e.g. a
-        // machine-token descriptor advertised to a direct-rail client); ignore
-        // hints that do not match this challenge instead of failing recovery on
-        // every attempt. Explicit caller descriptors keep failing loudly in
-        // recovery validation.
-        const recoverable = context?.descriptor !== undefined ||
-            (isSameAddress(recoverContext.descriptor.payee, resolved.payee) &&
-                isSameAddress(recoverContext.descriptor.token, resolved.token));
-        if (recoverable)
-            return {
-                type: 'recover',
-                account,
-                context: recoverContext,
-                decimals,
-                maxDeposit,
-                resolved,
-            };
+        return {
+            type: 'recover',
+            account,
+            context: recoverContext,
+            decimals,
+            maxDeposit,
+            resolved,
+        };
     }
     if (entry?.opened && canSignDescriptor(account, entry.descriptor))
         return { type: 'voucher', account, entry, maxDeposit, resolved };
     return { type: 'open', account, context, maxDeposit, resolved };
 }
 /** Executes a credential plan and returns the concrete session credential payload. */
-export async function executeCredentialPlan(plan, autoSwap = false, feeToken) {
+export async function executeCredentialPlan(plan, sink, autoSwap = false) {
     switch (plan.type) {
         case 'open':
-            return open(plan, autoSwap, feeToken);
+            return open(plan, sink, autoSwap);
         case 'recover':
-            return recover(plan);
+            return recover(plan, sink);
         case 'voucher':
-            return voucher(plan);
+            return voucher(plan, sink);
         case 'manual':
-            return manual(plan, autoSwap, feeToken);
+            return manual(plan, sink, autoSwap);
     }
 }
 async function resolveAutoSwapCalls(autoSwap, parameters) {
@@ -329,7 +334,7 @@ async function resolveAutoSwapCalls(autoSwap, parameters) {
         slippage: autoSwap.slippage,
     }));
 }
-async function open(plan, autoSwap, feeToken) {
+async function open(plan, sink, autoSwap) {
     const { account, resolved } = plan;
     const deposit = resolveOpeningDeposit({
         contextDepositRaw: plan.context?.depositRaw,
@@ -342,7 +347,7 @@ async function open(plan, autoSwap, feeToken) {
         deposit,
         escrow: resolved.escrow,
         feePayer: resolved.feePayer,
-        feeToken,
+        feeToken: resolved.feeToken,
         initialAmount: resolved.amount,
         operator: resolved.operator,
         payee: resolved.payee,
@@ -354,21 +359,18 @@ async function open(plan, autoSwap, feeToken) {
         }),
         token: resolved.token,
     });
-    return {
-        payload,
-        entry: {
-            channelId: payload.channelId,
-            cumulativeAmount: resolved.amount,
-            deposit,
-            descriptor: payload.descriptor,
-            escrow: resolved.escrow,
-            chainId: resolved.chainId,
-            opened: true,
-            ...(resolved.paymentScope && { paymentScope: resolved.paymentScope }),
-        },
-    };
+    await storeChannelEntry(sink, {
+        channelId: payload.channelId,
+        cumulativeAmount: resolved.amount,
+        deposit,
+        descriptor: payload.descriptor,
+        escrow: resolved.escrow,
+        chainId: resolved.chainId,
+        opened: true,
+    });
+    return payload;
 }
-async function recover(plan) {
+async function recover(plan, sink) {
     const { account, context, decimals, maxDeposit, resolved } = plan;
     const { descriptor } = context;
     const reusable = await resolveReusableChannel({
@@ -395,28 +397,27 @@ async function recover(plan) {
         throw new Error('recovered voucher amount exceeds on-chain channel deposit');
     assertWithinMaxDeposit(cumulativeAmount, maxDeposit);
     const payload = await createVoucherPayload(resolved.client, account, descriptor, cumulativeAmount, resolved.chainId, resolved.escrow);
-    return {
-        payload,
-        entry: {
-            channelId: reusable.channelId,
-            cumulativeAmount,
-            deposit: reusable.state.deposit,
-            descriptor,
-            escrow: resolved.escrow,
-            chainId: resolved.chainId,
-            opened: true,
-            ...(resolved.paymentScope && { paymentScope: resolved.paymentScope }),
-        },
-    };
+    await storeChannelEntry(sink, {
+        channelId: reusable.channelId,
+        cumulativeAmount,
+        deposit: reusable.state.deposit,
+        descriptor,
+        escrow: resolved.escrow,
+        chainId: resolved.chainId,
+        opened: true,
+    });
+    return payload;
 }
-async function voucher(plan) {
+async function voucher(plan, sink) {
     const { account, entry, resolved } = plan;
     const cumulativeAmount = entry.cumulativeAmount + resolved.amount;
     assertWithinMaxDeposit(cumulativeAmount, plan.maxDeposit);
     const payload = await createVoucherPayload(resolved.client, account, entry.descriptor, cumulativeAmount, resolved.chainId, resolved.escrow);
-    return { payload, entry: { ...entry, cumulativeAmount } };
+    entry.cumulativeAmount = cumulativeAmount;
+    await storeChannelEntry(sink, entry);
+    return payload;
 }
-async function manual(plan, autoSwap, feeToken) {
+async function manual(plan, sink, autoSwap) {
     const { account, context, decimals, resolved } = plan;
     const { descriptor } = context;
     const channelId = Channel.computeId({
@@ -440,15 +441,16 @@ async function manual(plan, autoSwap, feeToken) {
         decimals,
         descriptor,
         resolved,
-    }, autoSwap, feeToken);
-    return { payload, entry: applyCredential(plan.entry, payload) };
+    }, autoSwap);
+    await applyCumulative(sink, resolved.key, payload);
+    return payload;
 }
-async function executeManualCredential(parameters, autoSwap, feeToken) {
+async function executeManualCredential(parameters, autoSwap) {
     switch (parameters.context.action) {
         case 'open':
             return manualOpen(parameters);
         case 'topUp':
-            return manualTopUp(parameters, autoSwap, feeToken);
+            return manualTopUp(parameters, autoSwap);
         case 'voucher':
             return manualVoucher(parameters);
         case 'close':
@@ -472,7 +474,7 @@ async function manualOpen(parameters) {
         authorizedSigner: descriptor.authorizedSigner,
     };
 }
-async function manualTopUp(parameters, autoSwap, feeToken) {
+async function manualTopUp(parameters, autoSwap) {
     const { account, channelId, context, decimals, descriptor, resolved } = parameters;
     const additionalDeposit = requireContextAmount(context, decimals, 'additionalDeposit', 'topUp');
     if (context.transaction) {
@@ -490,7 +492,7 @@ async function manualTopUp(parameters, autoSwap, feeToken) {
         amountOut: additionalDeposit,
         client: resolved.client,
         tokenOut: resolved.token,
-    }), feeToken);
+    }), resolved.feeToken);
 }
 function manualVoucher(parameters) {
     const { account, context, decimals, descriptor, resolved } = parameters;

package/dist/tempo/session/client/Session.d.ts

@@ -1,4 +1,4 @@
-import { type Account as ViemAccount, type Address } from 'viem';
+import { type Address } from 'viem';
 import * as Method from '../../../Method.js';
 import * as Account from '../../../viem/Account.js';
 import * as Client from '../../../viem/Client.js';
@@ -22,7 +22,6 @@ export declare function session(parameters?: session.Parameters): Method.Client<
         credential: {
             payload: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"open">;
-                authorizationSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 authorizedSigner: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 channelId: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
@@ -39,18 +38,15 @@ export declare function session(parameters?: session.Parameters): Method.Client<
                 type: import("zod/mini").ZodMiniLiteral<"transaction">;
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"voucher">;
-                authorizationSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 channelId: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
                 descriptor: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<Channel.ChannelDescriptor, Channel.ChannelDescriptor>>;
                 signature: import("zod/mini").ZodMiniString<string>;
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"close">;
-                authorizationSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 channelId: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
                 descriptor: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<Channel.ChannelDescriptor, Channel.ChannelDescriptor>>;
-                refundSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 signature: import("zod/mini").ZodMiniString<string>;
             }, import("zod/v4/core").$strip>], "action">;
         };
@@ -61,9 +57,8 @@ export declare function session(parameters?: session.Parameters): Method.Client<
             currency: import("zod/mini").ZodMiniString<string>;
             decimals: import("zod/mini").ZodMiniNumber<number>;
             escrowContract: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
-            feePayer: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniBoolean<boolean>, import("zod/mini").ZodMiniCustom<ViemAccount, ViemAccount>]>, import("zod/mini").ZodMiniTransform<boolean, boolean | ViemAccount>>>;
+            feePayer: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniBoolean<boolean>, import("zod/mini").ZodMiniCustom<import("viem").Account, import("viem").Account>]>, import("zod/mini").ZodMiniTransform<boolean, boolean | import("viem").Account>>>;
             feeToken: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
-            machineTokenEnabled: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniBoolean<boolean>>;
             minVoucherDelta: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             operator: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             recipient: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
@@ -87,7 +82,6 @@ export declare function session(parameters?: session.Parameters): Method.Client<
                 chainId?: number | undefined;
                 feePayer?: boolean | undefined;
                 feeToken?: string | undefined;
-                machineTokenEnabled?: boolean | undefined;
                 operator?: string | undefined;
                 sessionProtocol?: "v1" | "v2" | undefined;
                 sessionSnapshot?: import("./Runtime.js").SessionSnapshot | undefined;
@@ -101,7 +95,6 @@ export declare function session(parameters?: session.Parameters): Method.Client<
             escrowContract?: string | undefined;
             feePayer?: boolean | undefined;
             feeToken?: string | undefined;
-            machineTokenEnabled?: boolean | undefined;
             minVoucherDelta?: string | undefined;
             operator?: string | undefined;
             recipient?: string | undefined;