@atumlabs/mppx-atum-escrow 0.1.1 → 0.2.2

package/dist/internal-DzEGXm14.d.ts

@@ -0,0 +1,347 @@
+import * as z from 'zod/mini';
+import { PaymentRequest } from './generated/index.js';
+import { Challenge, Credential } from 'mppx';
+
+/**
+ * A message that has been cryptographically signed to prove authorization.
+ * The signature proves you control the wallet that's sending funds.
+ *
+ */
+type SignedMessage = {
+    /**
+     * The data that was signed. Format depends on the blockchain:
+     * - EVM: Hex-encoded message hash (with 0x prefix)
+     * - Solana: Base64 encoded message
+     * - Tron: Hex-encoded message hash (possibly without 0x prefix)
+     *
+     */
+    message: string;
+    /**
+     * Optional: If 'message' contains a hash, this field contains the original data
+     * before it was hashed. Useful for verification and debugging.
+     *
+     */
+    message_prehash?: string;
+    /**
+     * The cryptographic signature proving you authorized this message.
+     * Format varies by blockchain (hex for EVM/Tron, base58 for Solana).
+     *
+     */
+    signature: string;
+};
+
+/**
+ * Chain defaults returned by the payment gateway /defaults endpoint.
+ */
+interface ChainDefaults {
+    escrowContract: string;
+    quoteSelector: string;
+    fulfillmentVerifierAccount: string;
+    fulfillmentVerifierEndpoint: string;
+    fulfillmentProxy: string;
+    permit2Contract?: string;
+    /**
+     * V3 Solana escrow domain-separation fields, surfaced by payment-gw
+     * `/defaults` for Solana source chains. Used to build the EscrowDomain that the
+     * V3 deposit hash binds to. Absent for EVM/Tron.
+     */
+    svmSignatureClusterId?: string;
+    svmSignatureDomainVersion?: number;
+}
+
+interface Logger {
+    debug(obj: unknown, msg?: string): void;
+    info(obj: unknown, msg?: string): void;
+    warn(obj: unknown, msg?: string): void;
+    error(obj: unknown, msg?: string): void;
+    child(bindings: Record<string, unknown>): Logger;
+}
+
+interface Counter {
+    add(value: number, attributes?: Record<string, unknown>): void;
+}
+interface Histogram {
+    record(value: number, attributes?: Record<string, unknown>): void;
+}
+interface InstrumentOptions {
+    description?: string;
+    unit?: string;
+}
+interface Meter {
+    createCounter(name: string, options?: InstrumentOptions): Counter;
+    createHistogram(name: string, options?: InstrumentOptions): Histogram;
+}
+
+/**
+ * Resolves the `issued_at` timestamp for a Solana deposit authorization from the
+ * cluster's on-chain clock instead of the local wall clock.
+ *
+ * The escrow validates `now_sec >= issued_at` against Solana's `Clock` sysvar
+ * (crates/replay/src/check.rs). That on-chain clock is global consensus and only
+ * moves forward, so a value read at build time is a safe lower bound at
+ * settlement, which removes the `Escrow_FutureTransaction` failure that a raw
+ * `Date.now()` (client wall clock, possibly ahead of the lagging cluster clock)
+ * can trigger.
+ *
+ * The read is best-effort: on any failure, timeout, or unresolved RPC it falls
+ * back to `Date.now()` minus a skew buffer, so a flaky public endpoint degrades
+ * to the previous behavior rather than blocking the payment.
+ */
+
+/** Reads the cluster's on-chain unix timestamp (seconds) from an RPC endpoint. */
+type SolanaClusterUnixTimeReader = (rpcUrl: string, timeoutMs: number) => Promise<bigint>;
+
+/** Result of signing a sender_auth message. */
+interface SenderSignature {
+    /** 0x-prefixed signature hex (65-byte secp256k1 for EVM/Tron, 64-byte ed25519 for Solana). */
+    signature: string;
+    /**
+     * base58 signer public key for non-recoverable schemes (Solana), attached to
+     * the signed message's payload.delegate_signer. Absent for EVM/Tron, whose
+     * secp256k1 signatures are recoverable.
+     */
+    delegateSigner?: string;
+}
+/** Signs a single sender_auth signed message for a payment request. */
+interface SenderSigner {
+    sign(signedMessage: SignedMessage): Promise<SenderSignature>;
+}
+/** Turnkey provider configuration (shared by the SDK and the CLI env loader). */
+interface TurnkeyConfig {
+    organizationId: string;
+    walletId: string;
+    apiPublicKey: string;
+    apiPrivateKey: string;
+    /**
+     * Chain-native address the signer is expected to resolve to. Verified against
+     * the address Turnkey returns at initialize(); a mismatch fails fast rather
+     * than signing as the wrong depositor.
+     */
+    pinnedAddress?: string;
+    /**
+     * Optional observability threaded to the Turnkey network path (default noop).
+     * SDK consumers can wire their own logger and meter; the CLI leaves them unset.
+     */
+    logger?: Logger;
+    meter?: Meter;
+}
+/** Options selecting a sender-signing provider. Defaults to the private-key provider. */
+type SenderSignerOptions = {
+    provider?: 'raw';
+    privateKey: string;
+    pinnedAddress?: string;
+} | ({
+    provider: 'turnkey';
+} & TurnkeyConfig);
+
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+/**
+ * The MPP `charge` challenge request — the method-specific `request` blob inside an mppx Challenge. It carries the source option the payer funds from plus the destination/corridor block (the reused `extra`). MPP has no x402 `accepts[]` envelope, so the source option that x402 carried at the `accepts[]` top level rides here alongside `extra`. One source option per challenge; a 402 may advertise several challenges to offer several source options.
+ */
+interface AtumEscrowRequest {
+    /**
+     * The source chain/token/cap the payer funds from.
+     */
+    source: {
+        /**
+         * CAIP-2 source chain id (e.g. eip155:8453).
+         */
+        network: string;
+        /**
+         * Source token address (EVM hex or base58, per the source chain).
+         */
+        asset: string;
+        /**
+         * Source spend cap (fulfillmentAmount + markup), in atomic token units — the authoritative `max_source_amount` the payer signs.
+         */
+        amount: string;
+    };
+    extra: AtumEscrowExtra;
+}
+/**
+ * The `extra.atum` object carried inside an atum-escrow x402 PaymentRequirements entry (accepts[]): the merchant's receive-side plus the contract/role addresses and deadline budgets. Scheme-specific data the standard x402 `extra` bag treats as opaque, so it is owned here and shared by all role mechanisms. Addresses are chain-general: an EVM `0x`-hex address (20 bytes) or a base58-encoded address (Solana/Tron), per the field's CAIP-2 chain.
+ */
+interface AtumEscrowExtra {
+    /**
+     * Where the merchant receives (CAIP-2 chain, token, address).
+     */
+    destination: {
+        /**
+         * CAIP-2 destination chain id (e.g. eip155:42161).
+         */
+        network: string;
+        /**
+         * Destination token contract address (EVM hex or base58, per the destination chain).
+         */
+        asset: string;
+        /**
+         * Merchant receive address (EVM hex or base58, per the destination chain).
+         */
+        address: string;
+    };
+    /**
+     * Exact amount the merchant receives, in atomic token units.
+     */
+    fulfillmentAmount: string;
+    /**
+     * Source-chain escrow contract (the x402 payTo); EVM hex or base58, per the source chain.
+     */
+    escrow: string;
+    /**
+     * Destination-chain fulfillment proxy contract (EVM hex or base58, per the destination chain).
+     */
+    fulfillmentProxy: string;
+    /**
+     * Atum reserver role address (escrow deposit witness); EVM hex or base58, per the source chain.
+     */
+    reserver: string;
+    /**
+     * Atum releaser role address (escrow deposit witness); EVM hex or base58, per the source chain.
+     */
+    releaser: string;
+    /**
+     * Source-chain fulfillment-verifier endpoint the payment request carries. The verifier account and the quote_selector are the releaser and reserver respectively (the network derives the deposit witness roles from them), so only the endpoint is not otherwise present in this object.
+     */
+    fulfillmentVerifierEndpoint: string;
+    /**
+     * Recommended quote-deadline budget in seconds, relative to signing time.
+     */
+    quoteDeadlineSeconds: number;
+    /**
+     * Recommended fulfillment-deadline budget in seconds, relative to signing time.
+     */
+    fulfillmentDeadlineSeconds: number;
+    /**
+     * Solana source only: cluster name used to build the 32-byte cluster_id in the V3 escrow signature domain. Optional; the facilitator requires it for a Solana source.
+     */
+    svmSignatureClusterId?: string;
+    /**
+     * Solana source only: escrow signature-domain version (V3 domain separation). Optional; required for a Solana source.
+     */
+    svmSignatureDomainVersion?: number;
+    /**
+     * Solana source only: merchant-stamped issue time in epoch seconds. The merchant reads the cluster clock so the client makes no RPC and the 402 stays self-contained. Optional; required for a Solana source.
+     */
+    issuedAt?: string;
+}
+
+/**
+ * Shared internals for the Atum escrow MPP method: the wire schemas, the method
+ * definition, the shared types, and the pure chain/address helpers used by both
+ * the payer ({@link ./client}) and merchant ({@link ./server}) sides.
+ *
+ * This module is not a public entry point — consumers import from the package
+ * root, `/client`, or `/server`. The helpers here are exported only so the
+ * client and server modules can share them.
+ *
+ * @internal
+ */
+
+/** The method name advertised in MPP challenges and credentials. */
+declare const METHOD_NAME = "atum-escrow";
+/** The MPP intent this method implements. */
+declare const INTENT = "charge";
+/**
+ * Schema for the `charge` challenge request — the method-specific data a merchant
+ * publishes in an MPP `402` challenge. It describes what the merchant receives and the
+ * source option the payer may fund from, so the payer can build the payment offline.
+ */
+declare const ChargeRequestSchema: z.ZodMiniObject<{
+    source: z.ZodMiniObject<{
+        network: z.ZodMiniString<string>;
+        asset: z.ZodMiniString<string>;
+        amount: z.ZodMiniString<string>;
+    }, z.core.$strip>;
+    extra: z.ZodMiniObject<{
+        destination: z.ZodMiniObject<{
+            network: z.ZodMiniString<string>;
+            asset: z.ZodMiniString<string>;
+            address: z.ZodMiniString<string>;
+        }, z.core.$strip>;
+        fulfillmentAmount: z.ZodMiniString<string>;
+        escrow: z.ZodMiniString<string>;
+        fulfillmentProxy: z.ZodMiniString<string>;
+        reserver: z.ZodMiniString<string>;
+        releaser: z.ZodMiniString<string>;
+        fulfillmentVerifierEndpoint: z.ZodMiniString<string>;
+        quoteDeadlineSeconds: z.ZodMiniNumber<number>;
+        fulfillmentDeadlineSeconds: z.ZodMiniNumber<number>;
+        svmSignatureClusterId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        svmSignatureDomainVersion: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+        issuedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Schema for the `charge` credential payload — the signed payment the payer returns in
+ * the MPP credential. It carries the Atum payment request; the request's signatures and
+ * terms are verified in full during server verification and by the Atum Payment Gateway,
+ * so this envelope validates only that the request is present.
+ */
+declare const CredentialPayloadSchema: z.ZodMiniObject<{
+    paymentRequest: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
+}, z.core.$strip>;
+/**
+ * The `charge` challenge request — the canonical `AtumEscrowRequest` shape (source option
+ * + the destination/corridor `extra`). The runtime schema above is verified against this
+ * type at compile time (below), so the validator and the canonical schema cannot drift.
+ */
+type ChargeRequest = AtumEscrowRequest;
+/** The `charge` credential payload, carrying the signed Atum payment request. */
+interface ChargeCredentialPayload {
+    /** The signed Atum payment request: source/destination, amounts, and authorizations. */
+    paymentRequest: PaymentRequest;
+}
+/**
+ * The MPP challenge for this method. Uses the schema's inferred type for the request
+ * (equal to {@link ChargeRequest} by the compile-time guard above, and compatible with
+ * the framework's `Record<string, unknown>` request constraint).
+ */
+type AtumEscrowChallenge = Challenge.Challenge<z.infer<typeof ChargeRequestSchema>, "charge", "atum-escrow">;
+/** The MPP credential for this method. */
+type AtumEscrowCredential = Credential.Credential<ChargeCredentialPayload, AtumEscrowChallenge>;
+/**
+ * The base `atum-escrow` charge method. Extend it with `registerClient` on the payer side
+ * and `registerServer` on the merchant side.
+ */
+declare const atumEscrowChargeMethod: {
+    readonly name: "atum-escrow";
+    readonly intent: "charge";
+    readonly schema: {
+        readonly request: z.ZodMiniObject<{
+            source: z.ZodMiniObject<{
+                network: z.ZodMiniString<string>;
+                asset: z.ZodMiniString<string>;
+                amount: z.ZodMiniString<string>;
+            }, z.core.$strip>;
+            extra: z.ZodMiniObject<{
+                destination: z.ZodMiniObject<{
+                    network: z.ZodMiniString<string>;
+                    asset: z.ZodMiniString<string>;
+                    address: z.ZodMiniString<string>;
+                }, z.core.$strip>;
+                fulfillmentAmount: z.ZodMiniString<string>;
+                escrow: z.ZodMiniString<string>;
+                fulfillmentProxy: z.ZodMiniString<string>;
+                reserver: z.ZodMiniString<string>;
+                releaser: z.ZodMiniString<string>;
+                fulfillmentVerifierEndpoint: z.ZodMiniString<string>;
+                quoteDeadlineSeconds: z.ZodMiniNumber<number>;
+                fulfillmentDeadlineSeconds: z.ZodMiniNumber<number>;
+                svmSignatureClusterId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                svmSignatureDomainVersion: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                issuedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        readonly credential: {
+            readonly payload: z.ZodMiniObject<{
+                paymentRequest: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
+            }, z.core.$strip>;
+        };
+    };
+};
+
+export { type AtumEscrowChallenge as A, type ChargeCredentialPayload as C, INTENT as I, METHOD_NAME as M, type SenderSigner as S, type AtumEscrowCredential as a, type AtumEscrowRequest as b, type ChargeRequest as c, ChargeRequestSchema as d, CredentialPayloadSchema as e, type SenderSignerOptions as f, atumEscrowChargeMethod as g, type SolanaClusterUnixTimeReader as h, type ChainDefaults as i };

package/dist/server.d.ts

@@ -1,8 +1,10 @@
 import * as zod_v4_core from 'zod/v4/core';
 import * as z from 'zod/mini';
-import { P as PaymentRequest, i as ChainDefaults, c as ChargeRequest } from './internal-CjcEyEsm.js';
-export { A as AtumEscrowChallenge, a as AtumEscrowCredential, C as ChargeCredentialPayload, d as ChargeRequestSchema, e as CredentialPayloadSchema, I as INTENT, M as METHOD_NAME, g as atumEscrowChargeMethod } from './internal-CjcEyEsm.js';
+import { i as ChainDefaults, c as ChargeRequest } from './internal-DzEGXm14.js';
+export { A as AtumEscrowChallenge, a as AtumEscrowCredential, C as ChargeCredentialPayload, d as ChargeRequestSchema, e as CredentialPayloadSchema, I as INTENT, M as METHOD_NAME, g as atumEscrowChargeMethod } from './internal-DzEGXm14.js';
 import { Receipt, Method } from 'mppx';
+import { PaymentRequest } from './generated/index.js';
+export { PaymentRequest } from './generated/index.js';
 
 /**
  * This file was automatically generated by json-schema-to-typescript.
@@ -69,8 +71,6 @@ interface AtumEscrowSource {
     releaser: string;
     /** Source-chain endpoint used to verify fulfillment. */
     fulfillmentVerifierEndpoint: string;
-    /** Tron-only: the Permit2 contract the deposit is signed against. Defaults to the known address for the cluster when omitted. */
-    permit2?: string;
     /** Solana-only: cluster id that domain-separates the deposit authorization. */
     svmSignatureClusterId?: string;
     /** Solana-only: signature domain version that domain-separates the deposit authorization. */
@@ -151,7 +151,7 @@ declare function registerServer(config: AtumEscrowServerConfig): Method.Server<{
                 destination: z.ZodMiniObject<{
                     network: z.ZodMiniString<string>;
                     asset: z.ZodMiniString<string>;
-                    account: z.ZodMiniString<string>;
+                    address: z.ZodMiniString<string>;
                 }, zod_v4_core.$strip>;
                 fulfillmentAmount: z.ZodMiniString<string>;
                 escrow: z.ZodMiniString<string>;
@@ -161,9 +161,9 @@ declare function registerServer(config: AtumEscrowServerConfig): Method.Server<{
                 fulfillmentVerifierEndpoint: z.ZodMiniString<string>;
                 quoteDeadlineSeconds: z.ZodMiniNumber<number>;
                 fulfillmentDeadlineSeconds: z.ZodMiniNumber<number>;
-                permit2: z.ZodMiniOptional<z.ZodMiniString<string>>;
                 svmSignatureClusterId: z.ZodMiniOptional<z.ZodMiniString<string>>;
                 svmSignatureDomainVersion: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                issuedAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
             }, zod_v4_core.$strip>;
         }, zod_v4_core.$strip>;
         readonly credential: {
@@ -191,12 +191,20 @@ declare function validateCorridor(corridor: AtumEscrowCorridor): void;
  * @param select - which configured source to fund from, by `(network, asset)`.
  * @param fulfillmentAmount - exact amount the merchant receives, atomic units of the
  *   destination token. Set per charge so one registration serves any price.
+ * @param options.issuedAt - Solana-source only: the merchant's cluster-clock reading (epoch
+ *   seconds) to stamp into `extra.issuedAt`, so the payer's client builds the deposit fully
+ *   offline (no RPC). Omit to let the client stamp `issued_at` from its own clock at signing
+ *   time — which keeps the full replay window; a merchant-stamped value anchors the window
+ *   earlier (at 402-build time), so only set it when the client genuinely cannot read a clock.
+ *   Ignored for EVM/Tron sources.
  * @throws if no source option matches `select`, or the corridor is invalid.
  */
 declare function buildChargeRequest(corridor: AtumEscrowCorridor, select: {
     network: string;
     asset: string;
-}, fulfillmentAmount: string): ChargeRequest;
+}, fulfillmentAmount: string, options?: {
+    issuedAt?: string;
+}): ChargeRequest;
 /** The minimal defaults source `corridorFromDefaults` needs; satisfied by the gateway client. */
 interface ChainDefaultsSource {
     fetchChainDefaults(chainId: string): Promise<ChainDefaults>;
@@ -227,4 +235,4 @@ declare function corridorFromDefaults(defaults: ChainDefaultsSource, params: {
     fulfillmentDeadlineSeconds: number;
 }): Promise<AtumEscrowCorridor>;
 
-export { type AtumEscrowCorridor, type AtumEscrowReceipt, type AtumEscrowServerConfig, type AtumEscrowSource, type ChainDefaultsSource, ChargeRequest, type FulfillmentConfirmation, PaymentRequest, type PaymentSubmitter, buildChargeRequest, corridorFromDefaults, registerServer, validateCorridor };
+export { type AtumEscrowCorridor, type AtumEscrowReceipt, type AtumEscrowServerConfig, type AtumEscrowSource, type ChainDefaultsSource, ChargeRequest, type FulfillmentConfirmation, type PaymentSubmitter, buildChargeRequest, corridorFromDefaults, registerServer, validateCorridor };

package/dist/server.js

@@ -10,14 +10,14 @@ import {
   corridorFromDefaults,
   registerServer,
   validateCorridor
-} from "./chunk-W6D2D767.js";
+} from "./chunk-NEM3HEZW.js";
 import {
   ChargeRequestSchema,
   CredentialPayloadSchema,
   INTENT,
   METHOD_NAME,
   atumEscrowChargeMethod
-} from "./chunk-2MWWLU75.js";
+} from "./chunk-4P34CLTO.js";
 export {
   ChargeRequestSchema,
   CredentialPayloadSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atumlabs/mppx-atum-escrow",
-  "version": "0.1.1",
+  "version": "0.2.2",
   "description": "Atum cross-chain escrow payment method for the Machine Payments Protocol (MPP).",
   "author": "Atum Labs, Inc.",
   "license": "SEE LICENSE IN LICENSE",
@@ -49,17 +49,18 @@
   "files": [
     "dist/**/*",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE",
     "THIRD-PARTY-NOTICES.txt"
   ],
   "scripts": {
-    "prebuild:deps": "node -e \"const {existsSync}=require('fs');for(const p of ['../contracts/evm/escrow-encoding/typescript/tsconfig.json','../contracts/tvm/escrow-encoding/typescript/tsconfig.json','../contracts/svm/escrow-encoding/typescript/tsconfig.json','../schemas/apis/atum-escrow/v1/bindings/typescript/tsconfig.json','../schemas/apis/fulfillment-confirmation/v1/bindings/typescript/tsconfig.json']){if(!existsSync(p)){console.error('bundled sibling not found at '+p+'. Is this checked out inside the protocol monorepo?');process.exit(1)}}if(!existsSync('../payment-gateway-client/dist/index.js')){console.error('@atum-labs/payment-gateway-client is not built. Run its build first (pnpm --filter @atum-labs/payment-gateway-client build).');process.exit(1)}\"",
-    "build:deps": "tsc -p ../contracts/evm/escrow-encoding/typescript/tsconfig.json && tsc -p ../contracts/tvm/escrow-encoding/typescript/tsconfig.json && tsc -p ../contracts/svm/escrow-encoding/typescript/tsconfig.json && tsc -p ../schemas/apis/atum-escrow/v1/bindings/typescript/tsconfig.json && tsc -p ../schemas/apis/fulfillment-confirmation/v1/bindings/typescript/tsconfig.json",
+    "prebuild:deps": "node -e \"const {existsSync}=require('fs');for(const p of ['../contracts/evm/escrow-encoding/typescript/tsconfig.json','../contracts/tvm/escrow-encoding/typescript/tsconfig.json','../contracts/svm/escrow-encoding/typescript/tsconfig.json','../schemas/apis/x402/v1/bindings/typescript/tsconfig.json','../schemas/apis/fulfillment-confirmation/v1/bindings/typescript/tsconfig.json','../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/tsconfig.json']){if(!existsSync(p)){console.error('bundled sibling not found at '+p+'. Is this checked out inside the protocol monorepo?');process.exit(1)}}if(!existsSync('../payment-gateway-client/dist/index.js')){console.error('@atum-labs/payment-gateway-client is not built. Run its build first (pnpm --filter @atum-labs/payment-gateway-client build).');process.exit(1)}\"",
+    "build:deps": "tsc -p ../contracts/evm/escrow-encoding/typescript/tsconfig.json && tsc -p ../contracts/tvm/escrow-encoding/typescript/tsconfig.json && tsc -p ../contracts/svm/escrow-encoding/typescript/tsconfig.json && tsc -p ../schemas/apis/x402/v1/bindings/typescript/tsconfig.json && tsc -p ../schemas/apis/fulfillment-confirmation/v1/bindings/typescript/tsconfig.json && tsc -p ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/tsconfig.json",
     "build": "pnpm run build:deps && tsup && node scripts/stamp-entry-headers.mjs",
     "typecheck": "pnpm run build:deps && tsc --noEmit",
     "pretest": "pnpm run build:deps",
     "test": "vitest run",
-    "clean": "rm -rf dist ../contracts/evm/escrow-encoding/typescript/dist ../contracts/tvm/escrow-encoding/typescript/dist ../contracts/svm/escrow-encoding/typescript/dist ../schemas/apis/atum-escrow/v1/bindings/typescript/dist ../schemas/apis/fulfillment-confirmation/v1/bindings/typescript/dist",
+    "clean": "rm -rf dist ../contracts/evm/escrow-encoding/typescript/dist ../contracts/tvm/escrow-encoding/typescript/dist ../contracts/svm/escrow-encoding/typescript/dist ../schemas/apis/x402/v1/bindings/typescript/dist ../schemas/apis/fulfillment-confirmation/v1/bindings/typescript/dist ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist",
     "check:publishable": "node scripts/check-publishable.mjs",
     "gen:notices": "node scripts/gen-third-party-notices.mjs",
     "prepare": "pnpm run build",
@@ -80,6 +81,8 @@
     "@atum-labs/evm-escrow-encoding": "workspace:*",
     "@atum-labs/fulfillment-confirmation": "workspace:*",
     "@atum-labs/payment-gateway-client": "workspace:*",
+    "@atum-labs/payment-request-sender-auth": "workspace:*",
+    "@atum-labs/publish-guard": "workspace:*",
     "@atum-labs/schema-declarations": "workspace:*",
     "@atum-labs/solana-escrow-encoding": "workspace:*",
     "@atum-labs/tvm-escrow-encoding": "workspace:*",

package/dist/chunk-L62WG2VU.js

@@ -1,131 +0,0 @@
-import { createRequire as __atumCreateRequire } from 'module'; const require = __atumCreateRequire(import.meta.url);
-import {
-  __toESM,
-  assetIdentifier,
-  atumEscrowChargeMethod,
-  chainDefaultsFromExtra,
-  namespaceOf,
-  require_dist,
-  require_dist2
-} from "./chunk-2MWWLU75.js";
-
-// src/client.ts
-var import_evm_escrow_encoding = __toESM(require_dist(), 1);
-var import_payment_gateway_client = __toESM(require_dist2(), 1);
-import { keccak256, toUtf8Bytes, Contract, MaxUint256 } from "ethers";
-import { Credential, Method } from "mppx";
-function registerClient(config) {
-  const now = config.now ?? (() => Date.now());
-  const gateway = new import_payment_gateway_client.PaymentGatewayClient();
-  return Method.toClient(atumEscrowChargeMethod, {
-    async createCredential({ challenge }) {
-      const { source, extra } = challenge.request;
-      const namespace = namespaceOf(source.network);
-      const account = config.account;
-      const nowMs = now();
-      if (!(extra.quoteDeadlineSeconds > 0 && extra.quoteDeadlineSeconds < extra.fulfillmentDeadlineSeconds)) {
-        throw new Error(
-          `atum-escrow: deadline ordering violated (now < quote_deadline < fulfillment_deadline); quoteDeadlineSeconds=${extra.quoteDeadlineSeconds}, fulfillmentDeadlineSeconds=${extra.fulfillmentDeadlineSeconds}`
-        );
-      }
-      const anchorAccount = namespace === "eip155" ? account.toLowerCase() : account;
-      const idempotencyAnchor = keccak256(
-        toUtf8Bytes(`atum-escrow:${challenge.id}:${anchorAccount}`)
-      );
-      const requestId = `req_mpp_${idempotencyAnchor.slice(2, 26)}`;
-      const sourceDefaults = chainDefaultsFromExtra(extra, source.network);
-      const sourceAssetId = assetIdentifier(source.network, source.asset);
-      const isSolana = namespace === "solana";
-      const paymentRequestGw = await gateway.preparePaymentRequest({
-        depositor: account,
-        fulfillmentAmount: extra.fulfillmentAmount,
-        sourceAsset: sourceAssetId,
-        destinationAccount: extra.destination.account,
-        destinationAsset: assetIdentifier(extra.destination.network, extra.destination.asset),
-        // Sign the full advertised cap. The payer MAY sign a lower value, but that only
-        // lowers its own escrow lock and risks the auction not clearing; the full cap is
-        // the safe default and never affects the receive side.
-        maxSourceAmount: source.amount,
-        requestId,
-        quoteDeadlineSeconds: extra.quoteDeadlineSeconds,
-        fulfillmentDeadlineSeconds: extra.fulfillmentDeadlineSeconds,
-        now: () => nowMs,
-        resolvedDefaults: {
-          source: sourceDefaults,
-          destination: { fulfillmentProxy: extra.fulfillmentProxy }
-        },
-        // EVM/Tron: thread the deterministic nonce, and keep the deposit deadline at least
-        // as late as the fulfillment deadline. The adapter floors the relative deadline, so
-        // +1s guards against truncating below fulfillment_deadline.
-        ...isSolana ? {
-          // Solana stamps issued_at from the (injectable) clock and derives its own
-          // replay-window deadline; the offline build reads the client clock.
-          solanaRpcUrl: "atum-escrow:offline",
-          solanaClockReader: config.solanaClockReader ?? (async () => BigInt(Math.floor(nowMs / 1e3)))
-        } : {
-          nonce: BigInt(idempotencyAnchor),
-          // Keep the deposit deadline at least as late as fulfillment. The adapter
-          // floors its relative deadline, so round the budget up and add a second to
-          // guard against truncating below fulfillment_deadline (and to keep an
-          // integer, since the adapter derives a bigint from it).
-          deadlineSeconds: Math.ceil(extra.fulfillmentDeadlineSeconds) + 1
-        }
-      });
-      const signer = buildSenderSigner(source.network, config.signer, account);
-      await (0, import_payment_gateway_client.signPaymentRequest)(paymentRequestGw, signer);
-      const paymentRequest = paymentRequestGw;
-      return Credential.serialize({
-        challenge,
-        payload: { paymentRequest },
-        source: `did:pkh:${source.network}:${anchorAccount}`
-      });
-    }
-  });
-}
-function isSenderSigner(signer) {
-  return typeof signer.sign === "function";
-}
-function buildSenderSigner(network, signer, account) {
-  if (isSenderSigner(signer)) {
-    return signer;
-  }
-  if (signer.provider === "turnkey") {
-    throw new Error(
-      "atum-escrow: construct a Turnkey SenderSigner with the payment-gateway client and pass it as `signer`"
-    );
-  }
-  return (0, import_payment_gateway_client.createSenderSigner)(network, {
-    provider: "raw",
-    privateKey: signer.privateKey,
-    pinnedAddress: signer.pinnedAddress ?? account
-  });
-}
-var ERC20_ALLOWANCE_ABI = [
-  "function allowance(address owner, address spender) view returns (uint256)",
-  "function approve(address spender, uint256 amount) returns (bool)"
-];
-async function ensureSourceApproval(params) {
-  if (namespaceOf(params.network) === "solana") {
-    return { alreadySufficient: true };
-  }
-  const spender = params.spender ?? (namespaceOf(params.network) === "eip155" ? import_evm_escrow_encoding.PERMIT2_CONTRACT_ADDRESS : void 0);
-  if (!spender) {
-    throw new Error(
-      `atum-escrow: a spender (Permit2 address) is required to approve on ${params.network}`
-    );
-  }
-  const erc20 = new Contract(params.token, ERC20_ALLOWANCE_ABI, params.signer);
-  const current = await erc20.allowance(params.owner, spender);
-  const sufficient = params.requiredAllowance !== void 0 ? current >= params.requiredAllowance : current >= MaxUint256;
-  if (sufficient) {
-    return { alreadySufficient: true };
-  }
-  const tx = await erc20.approve(spender, MaxUint256);
-  await tx.wait?.();
-  return { alreadySufficient: false, txHash: tx.hash };
-}
-
-export {
-  registerClient,
-  ensureSourceApproval
-};