mppx 0.8.18 → 0.9.0

package/dist/tempo/internal/machine-token-session.d.ts

@@ -1,88 +0,0 @@
-import type * as Hex from 'ox/Hex';
-import { type Account, type Address, type Client } from 'viem';
-import * as defaults from './defaults.js';
-type Deployment = (typeof defaults.machineToken)[keyof typeof defaults.machineToken];
-/** Verified machine-token session route. */
-export type Route = {
-    operator: Address;
-    payee: Address;
-    token: Address;
-};
-type Authorization = {
-    channelId: Hex.Hex;
-    cumulativeAmount: bigint;
-};
-/** Returns whether a unified machine-token router is configured on a chain. */
-export declare function isSupported(chainId: number | undefined): boolean;
-/** Matches a session descriptor to the configured router and machine token. */
-export declare function matchDeployment(parameters: {
-    chainId: number | undefined;
-    descriptor: {
-        operator: Address;
-        token: Address;
-    };
-}): Deployment | undefined;
-/** Returns whether an authenticated session challenge permits the machine-token rail. */
-export declare function isEnabledChallenge(challenge: {
-    request: {
-        methodDetails?: unknown;
-    };
-}): boolean;
-/** Resolves the fee token from the payment token and an optional explicit override. */
-export declare function resolveFeeToken(parameters: {
-    chainId: number | undefined;
-    override?: Address | undefined;
-    paymentToken: Address;
-}): Address;
-/**
- * Resolves the fee tokens accepted for direct-rail sponsored transactions.
- * Clients released before the fee-token advertisement always pay sponsored
- * fees in the payment token, so it stays accepted alongside a configured
- * override. Machine-rail routes post-date the advertisement and pin a single
- * token via {@link resolveFeeToken}.
- */
-export declare function allowedSponsoredFeeTokens(parameters: {
-    chainId: number | undefined;
-    override?: Address | undefined;
-    paymentToken: Address;
-}): readonly Address[];
-/** Returns whether an account has enough of a TIP-20 token for an operation. */
-export declare function hasSufficientBalance(client: Client, parameters: {
-    account: Address;
-    amount: bigint;
-    token: Address;
-}): Promise<boolean>;
-/** Signs a cumulative amount in the router-specific authorization domain. */
-export declare function signAuthorization(client: Client, account: Account, parameters: {
-    authorization: Authorization;
-    chainId: number;
-    router: Address;
-}): Promise<Hex.Hex>;
-/** Verifies a cumulative authorization in the router-specific domain. */
-export declare function verifyAuthorization(parameters: {
-    authorization: Authorization;
-    chainId: number;
-    expectedSigner: Address;
-    router: Address;
-    signature: Hex.Hex;
-}): boolean;
-/** Resolves the active virtual payee and verifies its immutable reverse binding. */
-export declare function resolveRoute(client: Client, parameters: {
-    chainId: number;
-    merchant: Address;
-    targetToken: Address;
-}): Promise<Route | undefined>;
-/** Verifies a descriptor against the trusted router and merchant payout binding. */
-export declare function matchRoute(client: Client, parameters: {
-    active?: boolean | undefined;
-    chainId: number;
-    descriptor: {
-        operator: Address;
-        payee: Address;
-        token: Address;
-    };
-    merchant: Address;
-    targetToken: Address;
-}): Promise<Route | undefined>;
-export {};
-//# sourceMappingURL=machine-token-session.d.ts.map

package/dist/tempo/internal/machine-token-session.js

@@ -1,173 +0,0 @@
-import { SignatureEnvelope } from 'ox/tempo';
-import { hashTypedData, isAddressEqual, parseAbi, zeroAddress, } from 'viem';
-import { readContract, signTypedData } from 'viem/actions';
-import { Actions } from 'viem/tempo';
-import { isAccessKeyAccount } from './account.js';
-import * as defaults from './defaults.js';
-import { parseCanonicalEnvelope, serializeCanonicalEnvelope } from './signature-envelope.js';
-const sessionRouteAbi = parseAbi([
-    'function sessionRouteFor(address merchant,address targetToken) view returns (address routeAddress)',
-    'function sessionRoutes(address routeAddress) view returns (address merchant,address targetToken)',
-]);
-const authorizationTypes = {
-    SessionAuthorization: [
-        { name: 'channelId', type: 'bytes32' },
-        { name: 'cumulativeAmount', type: 'uint96' },
-    ],
-};
-function getDeployment(chainId) {
-    if (chainId === undefined)
-        return undefined;
-    return defaults.machineToken[chainId];
-}
-/** Returns whether a unified machine-token router is configured on a chain. */
-export function isSupported(chainId) {
-    return !!getDeployment(chainId);
-}
-/** Matches a session descriptor to the configured router and machine token. */
-export function matchDeployment(parameters) {
-    const deployment = getDeployment(parameters.chainId);
-    return deployment &&
-        isAddressEqual(parameters.descriptor.operator, deployment.swap) &&
-        isAddressEqual(parameters.descriptor.token, deployment.token)
-        ? deployment
-        : undefined;
-}
-/** Returns whether an authenticated session challenge permits the machine-token rail. */
-export function isEnabledChallenge(challenge) {
-    return (challenge.request.methodDetails
-        ?.machineTokenEnabled === true);
-}
-/** Resolves the fee token from the payment token and an optional explicit override. */
-export function resolveFeeToken(parameters) {
-    if (parameters.override)
-        return parameters.override;
-    const deployment = getDeployment(parameters.chainId);
-    if (deployment && isAddressEqual(parameters.paymentToken, deployment.token))
-        return defaults.tokens.pathUsd;
-    return parameters.paymentToken;
-}
-/**
- * Resolves the fee tokens accepted for direct-rail sponsored transactions.
- * Clients released before the fee-token advertisement always pay sponsored
- * fees in the payment token, so it stays accepted alongside a configured
- * override. Machine-rail routes post-date the advertisement and pin a single
- * token via {@link resolveFeeToken}.
- */
-export function allowedSponsoredFeeTokens(parameters) {
-    const feeToken = resolveFeeToken(parameters);
-    if (isAddressEqual(feeToken, parameters.paymentToken))
-        return [feeToken];
-    return [feeToken, parameters.paymentToken];
-}
-/** Returns whether an account has enough of a TIP-20 token for an operation. */
-export async function hasSufficientBalance(client, parameters) {
-    try {
-        const balance = await readContract(client, Actions.token.getBalance.call(client, {
-            account: parameters.account,
-            token: parameters.token,
-        }));
-        return balance >= parameters.amount;
-    }
-    catch {
-        return false;
-    }
-}
-function authorizationDomain(router, chainId) {
-    return {
-        name: 'MachineUSD Session Router',
-        version: '1',
-        chainId,
-        verifyingContract: router,
-    };
-}
-function hashAuthorization(parameters) {
-    return hashTypedData({
-        domain: authorizationDomain(parameters.router, parameters.chainId),
-        types: authorizationTypes,
-        primaryType: 'SessionAuthorization',
-        message: parameters.authorization,
-    });
-}
-/** Signs a cumulative amount in the router-specific authorization domain. */
-export async function signAuthorization(client, account, parameters) {
-    const signature = isAccessKeyAccount(account)
-        ? await account.sign({
-            hash: hashAuthorization(parameters),
-            raw: true,
-        })
-        : await signTypedData(client, {
-            account,
-            domain: authorizationDomain(parameters.router, parameters.chainId),
-            types: authorizationTypes,
-            primaryType: 'SessionAuthorization',
-            message: parameters.authorization,
-        });
-    return serializeCanonicalEnvelope(signature, 'Machine-token session authorizations');
-}
-/** Verifies a cumulative authorization in the router-specific domain. */
-export function verifyAuthorization(parameters) {
-    try {
-        const envelope = parseCanonicalEnvelope(parameters.signature);
-        if (!envelope)
-            return false;
-        const payload = hashAuthorization(parameters);
-        return SignatureEnvelope.verify(envelope, { address: parameters.expectedSigner, payload });
-    }
-    catch {
-        return false;
-    }
-}
-async function readRoute(client, deployment, parameters) {
-    const payee = parameters.payee ??
-        (await readContract(client, {
-            address: deployment.swap,
-            abi: sessionRouteAbi,
-            functionName: 'sessionRouteFor',
-            args: [parameters.merchant, parameters.targetToken],
-        }));
-    if (isAddressEqual(payee, zeroAddress))
-        return undefined;
-    const [binding, activePayee] = await Promise.all([
-        readContract(client, {
-            address: deployment.swap,
-            abi: sessionRouteAbi,
-            functionName: 'sessionRoutes',
-            args: [payee],
-        }),
-        parameters.active && parameters.payee
-            ? readContract(client, {
-                address: deployment.swap,
-                abi: sessionRouteAbi,
-                functionName: 'sessionRouteFor',
-                args: [parameters.merchant, parameters.targetToken],
-            })
-            : payee,
-    ]);
-    if (isAddressEqual(binding[0], zeroAddress) ||
-        isAddressEqual(binding[1], zeroAddress) ||
-        !isAddressEqual(binding[0], parameters.merchant) ||
-        !isAddressEqual(binding[1], parameters.targetToken) ||
-        !isAddressEqual(activePayee, payee))
-        return undefined;
-    return { operator: deployment.swap, payee, token: deployment.token };
-}
-/** Resolves the active virtual payee and verifies its immutable reverse binding. */
-export async function resolveRoute(client, parameters) {
-    const deployment = getDeployment(parameters.chainId);
-    if (!deployment)
-        return undefined;
-    return readRoute(client, deployment, { ...parameters, active: true });
-}
-/** Verifies a descriptor against the trusted router and merchant payout binding. */
-export async function matchRoute(client, parameters) {
-    const deployment = matchDeployment(parameters);
-    if (!deployment)
-        return undefined;
-    return readRoute(client, deployment, {
-        ...parameters,
-        active: parameters.active !== false,
-        payee: parameters.descriptor.payee,
-    });
-}
-//# sourceMappingURL=machine-token-session.js.map

package/dist/tempo/internal/signature-envelope.d.ts

@@ -1,14 +0,0 @@
-import { SignatureEnvelope } from 'ox/tempo';
-import type { Hex } from 'viem';
-/**
- * Canonicalizes a fresh TIP-1020 primitive signature for transport. Keychain
- * wrappers, multisig signatures, and magic-suffixed encodings are rejected.
- */
-export declare function serializeCanonicalEnvelope(signature: Hex, subject: string): Hex;
-/**
- * Parses an incoming signature into a canonical TIP-1020 primitive envelope.
- * Returns `undefined` for wrapper envelopes and aliased (non-canonical)
- * encodings, so verified signatures can be replayed on-chain byte-for-byte.
- */
-export declare function parseCanonicalEnvelope(signature: Hex): SignatureEnvelope.SignatureEnvelope | undefined;
-//# sourceMappingURL=signature-envelope.d.ts.map

package/dist/tempo/internal/signature-envelope.js

@@ -1,28 +0,0 @@
-import { SignatureEnvelope } from 'ox/tempo';
-function isPrimitiveEnvelope(type) {
-    return type === 'secp256k1' || type === 'p256' || type === 'webAuthn';
-}
-/**
- * Canonicalizes a fresh TIP-1020 primitive signature for transport. Keychain
- * wrappers, multisig signatures, and magic-suffixed encodings are rejected.
- */
-export function serializeCanonicalEnvelope(signature, subject) {
-    const envelope = SignatureEnvelope.from(signature);
-    if (!isPrimitiveEnvelope(envelope.type))
-        throw new Error(`${subject} require a TIP-1020 primitive signature; received "${envelope.type}".`);
-    return SignatureEnvelope.serialize(envelope);
-}
-/**
- * Parses an incoming signature into a canonical TIP-1020 primitive envelope.
- * Returns `undefined` for wrapper envelopes and aliased (non-canonical)
- * encodings, so verified signatures can be replayed on-chain byte-for-byte.
- */
-export function parseCanonicalEnvelope(signature) {
-    const envelope = SignatureEnvelope.from(signature);
-    if (!isPrimitiveEnvelope(envelope.type))
-        return undefined;
-    if (SignatureEnvelope.serialize(envelope).toLowerCase() !== signature.toLowerCase())
-        return undefined;
-    return envelope;
-}
-//# sourceMappingURL=signature-envelope.js.map