@atumlabs/mppx-atum-escrow 0.1.1 → 0.3.0

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 { Receipt, Method } from 'mppx';
+import { j as ChainDefaults, c as ChargeRequest } from './internal-9tB7y-A7.js';
+export { A as AtumEscrowChallenge, a as AtumEscrowCredential, C as ChargeCredentialPayload, d as ChargeRequestSchema, e as CredentialPayloadSchema, I as INTENT, f as INTENT_ID_META_KEY, M as METHOD_NAME, h as atumEscrowChargeMethod } from './internal-9tB7y-A7.js';
+import { Errors, 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.
@@ -51,6 +53,131 @@ interface FulfillmentConfirmation {
     destination_block_number?: number;
 }
 
+/**
+ * Settlement outcomes that are not a receipt.
+ *
+ * MPP models a completed payment and nothing else: a receipt's status is the literal
+ * `"success"`, so a payment that has not settled cannot be expressed as one and has to leave
+ * `verify()` as a throw. What matters is that the two non-success outcomes stay
+ * distinguishable, because they call for opposite responses:
+ *
+ * - {@link SettlementPendingError} — the payment is still settling. Retrying the SAME purchase
+ *   is safe and is how the payer collects the result: the identifier it derives from resolves to
+ *   this same payment, so the gateway returns the original rather than charging again.
+ * - {@link SettlementFailedError} — the payment reached a terminal failure. Retrying the same
+ *   purchase resolves to the dead payment forever, so recovering means starting a NEW purchase
+ *   under a new identifier.
+ *
+ * Both carry the gateway's payment id when one was issued, so a merchant can reconcile the
+ * attempt against the gateway without parsing a message.
+ *
+ * Both extend the framework's error types, so a merchant that does not distinguish them still
+ * gets the standard `402` + problem-details response.
+ *
+ * @packageDocumentation
+ */
+
+/** Fields shared by both settlement outcomes. */
+interface SettlementErrorDetails {
+    /** The gateway's payment id, when the payment was accepted and given one. */
+    readonly paymentId: string | undefined;
+}
+/** True if the payment is still settling — a retry of the same purchase is safe. */
+declare function isSettlementPending(err: unknown): err is SettlementPendingError;
+/** True if the payment reached a terminal failure — the same purchase can never settle. */
+declare function isSettlementFailed(err: unknown): err is SettlementFailedError;
+/** True if the gateway refused the request outright — nothing was charged. */
+declare function isPaymentRejected(err: unknown): err is PaymentRejectedError;
+/**
+ * The payment was accepted but had not settled when the merchant's synchronous window closed.
+ *
+ * Not a failure: the payment is in flight. Re-attempting the same purchase is safe — it resolves to
+ * this payment and returns its result once settled.
+ *
+ * **What re-attempting means.** Run the purchase again: request a fresh challenge and sign it again,
+ * keeping the same intent id. The intent id is what makes the re-attempt resolve onto the payment
+ * already in flight rather than taking a second one, so it must not change — while everything
+ * time-bound about the authorization must, because the deadlines are absolute timestamps fixed when
+ * it was signed. A stored credential therefore cannot simply be presented a second time; once its
+ * quote window has closed it is refused, and on Solana the deposit authorization carries its own
+ * replay window that expires with it.
+ *
+ * A payment-enabled `fetch` does this for the caller, since each attempt fetches a new challenge.
+ * Code that drives the client directly has to rebuild.
+ */
+declare class SettlementPendingError extends Errors.PaymentActionRequiredError implements SettlementErrorDetails {
+    /** Discriminant; test it with {@link isSettlementPending}. */
+    readonly isSettlementPending: true;
+    readonly paymentId: string | undefined;
+    constructor(options?: {
+        paymentId?: string | undefined;
+    });
+    /**
+     * Adds `paymentId` as its own field, not just interpolated into `detail`'s prose. A merchant
+     * catching this in-process already has `.paymentId`; a real cross-network payer only ever
+     * sees this JSON body, and without a dedicated field would have to parse it out of a sentence
+     * to reconcile the attempt against the gateway. The return type is declared (not left to
+     * inference) so a TypeScript merchant that re-serializes through the base type still sees
+     * `paymentId` in intellisense.
+     */
+    toProblemDetails(challengeId?: string): Errors.PaymentError.ProblemDetails & {
+        paymentId?: string;
+    };
+}
+/**
+ * The payment reached a terminal failure state and will not settle.
+ *
+ * A retry of the same purchase cannot recover it: that purchase's identifier now resolves to
+ * this failed payment. Recovering means a new purchase under a new identifier.
+ */
+declare class SettlementFailedError extends Errors.VerificationFailedError implements SettlementErrorDetails {
+    /** Discriminant; test it with {@link isSettlementFailed}. */
+    readonly isSettlementFailed: true;
+    readonly paymentId: string | undefined;
+    /** The terminal state the gateway reported. */
+    readonly state: string;
+    constructor(options: {
+        paymentId?: string | undefined;
+        state: string;
+    });
+    /**
+     * Adds `paymentId` and `state` as their own fields, not just interpolated into `detail`'s
+     * prose — see {@link SettlementPendingError.toProblemDetails} for why a payer needs this on
+     * the wire, not only a same-process merchant. Return type declared for the same reason: so a
+     * TypeScript merchant sees `paymentId`/`state` in intellisense, not only at runtime.
+     */
+    toProblemDetails(challengeId?: string): Errors.PaymentError.ProblemDetails & {
+        paymentId?: string;
+        state: string;
+    };
+}
+/**
+ * The gateway refused the payment outright — it never entered settlement.
+ *
+ * Distinct from {@link SettlementFailedError}: nothing was charged and nothing is in flight, so
+ * the fault is in the request and fixing it makes the same purchase payable. The most common
+ * cause is reusing one purchase identifier for two different sets of terms, which the gateway
+ * rejects rather than silently resolving to the first payment.
+ *
+ * Thrown by a {@link ../server!PaymentSubmitter | PaymentSubmitter} — the submitter owns the
+ * gateway call, so it is the only place that can tell a refusal (the request was rejected) from
+ * a transport or server failure (the outcome is unknown, and reporting it as a refusal would
+ * invite a second payment). Classify on the response status rather than on the body, so an
+ * intermediary that rewrites the error payload cannot turn a refusal into an unknown outcome.
+ * Raising it preserves the gateway's error code through to the payer instead of flattening every
+ * cause into one generic verification failure.
+ */
+declare class PaymentRejectedError extends Errors.BadRequestError {
+    /** Discriminant; test it with {@link isPaymentRejected}. */
+    readonly isPaymentRejected: true;
+    /** The gateway's error code, for programmatic handling. */
+    readonly code: string;
+    constructor(options: {
+        code: string;
+        detail: string;
+    });
+}
+
 /** One source chain/token the merchant accepts payment from. */
 interface AtumEscrowSource {
     /** CAIP-2 source chain id (e.g. `eip155:8453`, `tron:mainnet`, `solana:<genesis>`). */
@@ -69,8 +196,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. */
@@ -95,15 +220,37 @@ interface AtumEscrowCorridor {
     /** Accepted source options; selected per charge by `(network, asset)`. */
     sources: AtumEscrowSource[];
 }
+/** Lifecycle state the gateway reports for a payment. */
+type PaymentSettlementStatus = "pending" | "completed" | "failed" | "cancelled";
+/** What a {@link PaymentSubmitter} resolves with. */
+interface PaymentSubmitResult {
+    /** The gateway's payment id. Present whenever the payment was accepted. */
+    payment_id?: string;
+    /**
+     * The payment's state. When absent, an unsettled payment is treated as still in flight —
+     * the conservative reading, since calling an in-flight payment failed would tell the payer to
+     * start a second one.
+     */
+    status?: PaymentSettlementStatus;
+    /** The settlement confirmation, present once the payment has completed. */
+    fulfillment_confirmation?: FulfillmentConfirmation;
+}
 /**
  * Submits a signed payment request to the Atum Payment Gateway and resolves with the
  * settlement result. Satisfied by an adapter over `@atum-labs/payment-gateway-client`.
+ *
+ * Submit and return what the gateway said; do not poll for completion inside the submitter.
+ * A payment that outlives the gateway's synchronous window surfaces to the payer as
+ * {@link SettlementPendingError}, and the payer's retry of the same purchase is what collects the
+ * result — the gateway resolves that retry to the same payment. Polling inside the submitter
+ * instead holds the merchant's request open for the full settlement window and hides the pending
+ * state that makes the retry safe.
+ *
+ * Throw {@link PaymentRejectedError} when the gateway refuses the request, so the refusal keeps
+ * its code. Any other throw is treated as an unknown outcome.
  */
 interface PaymentSubmitter {
-    submit(request: PaymentRequest): Promise<{
-        payment_id?: string;
-        fulfillment_confirmation?: FulfillmentConfirmation;
-    }>;
+    submit(request: PaymentRequest): Promise<PaymentSubmitResult>;
 }
 /** Configuration for the merchant side of the method. */
 interface AtumEscrowServerConfig {
@@ -151,7 +298,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 +308,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: {
@@ -182,21 +329,91 @@ declare function registerServer(config: AtumEscrowServerConfig): Method.Server<{
  */
 declare function validateCorridor(corridor: AtumEscrowCorridor): void;
 /**
- * Build the `charge` challenge request for a specific source option from a corridor. The
- * merchant uses this to construct the 402 challenge; the source cap is
- * `fulfillmentAmount + markup`, quoted in the source token. The corridor is validated
- * first, so a misconfiguration fails here rather than at signing time.
+ * Build the `charge` challenge request for a specific source option from a corridor — the
+ * payment terms alone. The source cap is `fulfillmentAmount + markup`, quoted in the source
+ * token. The corridor is validated first, so a misconfiguration fails here rather than at
+ * signing time.
+ *
+ * Prefer {@link buildChargeChallenge}, which pairs these terms with the per-purchase identifier
+ * the payer requires. A challenge built from this function alone carries no such identifier and
+ * the payer's client refuses it — at signing time, not at build time, so code that calls this
+ * directly and worked before only surfaces the problem when a real payer's client refuses the
+ * payment. Reach for it directly only when supplying the per-purchase metadata by hand.
  *
  * @param corridor - the corridor to serve.
  * @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;
+/**
+ * A charge challenge's two halves, ready to hand to the framework.
+ *
+ * They are separate because the framework keeps them separate: `request` is the
+ * method-specific payment terms, `meta` is challenge metadata. Both are covered by the
+ * challenge-id HMAC, but nesting the metadata inside the request would bury the purchase
+ * identifier in the terms blob where the payer does not look for it — so this type keeps them in
+ * the shape the framework expects.
+ */
+interface ChargeChallenge {
+    /** The method-specific charge request (the payment terms). */
+    request: ChargeRequest;
+    /** Challenge metadata carrying the per-intent identifier. */
+    meta: Record<string, string>;
+}
+/**
+ * Build a charge challenge for a specific source option from a corridor.
+ *
+ * This is the entry point a merchant should use: it pairs the payment terms with the per-purchase
+ * identifier the payer needs to make the payment retry-safe. A challenge built without that
+ * identifier is refused by the payer's client rather than paid unsafely.
+ *
+ * Pass the result straight through to the framework:
+ *
+ * ```ts
+ * const { request, meta } = buildChargeChallenge(corridor, source, amount, { intentId: order.id })
+ *
+ * // Route-handler style:
+ * mppx.compose(['atum-escrow/charge', { ...request, meta }])(input)
+ *
+ * // Or building the challenge directly:
+ * Challenge.fromMethod(atumEscrowChargeMethod, { request, meta, realm, secretKey })
+ * ```
+ *
+ * @param corridor - the corridor to serve.
+ * @param select - which configured source to fund from, by `(network, asset)`.
+ * @param fulfillmentAmount - exact amount the merchant receives, atomic units of the
+ *   destination token.
+ * @param options.intentId - identifies the thing being bought. Use the merchant's own order,
+ *   invoice, or cart identifier: one value per purchase, the SAME value every time that purchase
+ *   is re-offered or retried, and never shared between two purchases. The payer derives the
+ *   payment's identity from it and the gateway de-duplicates on that, so its lifetime is what
+ *   decides whether a retry is recognized (a value that changes per attempt causes a second
+ *   charge) and whether two purchases stay distinct (a value shared between them leaves the
+ *   second unpaid). Do not derive it from the terms: two orders for the same item have identical
+ *   terms.
+ * @param options.issuedAt - Solana-source only; see {@link buildChargeRequest}.
+ * @throws if `intentId` is empty, or the corridor/source selection is invalid.
+ */
+declare function buildChargeChallenge(corridor: AtumEscrowCorridor, select: {
+    network: string;
+    asset: string;
+}, fulfillmentAmount: string, options: {
+    intentId: string;
+    issuedAt?: string;
+}): ChargeChallenge;
 /** The minimal defaults source `corridorFromDefaults` needs; satisfied by the gateway client. */
 interface ChainDefaultsSource {
     fetchChainDefaults(chainId: string): Promise<ChainDefaults>;
@@ -227,4 +444,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, type ChargeChallenge, ChargeRequest, type FulfillmentConfirmation, PaymentRejectedError, type PaymentSettlementStatus, type PaymentSubmitResult, type PaymentSubmitter, type SettlementErrorDetails, SettlementFailedError, SettlementPendingError, buildChargeChallenge, buildChargeRequest, corridorFromDefaults, isPaymentRejected, isSettlementFailed, isSettlementPending, registerServer, validateCorridor };

package/dist/server.js

@@ -6,26 +6,42 @@
  */
 import { createRequire as __atumCreateRequire } from 'module'; const require = __atumCreateRequire(import.meta.url);
 import {
+  PaymentRejectedError,
+  SettlementFailedError,
+  SettlementPendingError,
+  buildChargeChallenge,
   buildChargeRequest,
   corridorFromDefaults,
+  isPaymentRejected,
+  isSettlementFailed,
+  isSettlementPending,
   registerServer,
   validateCorridor
-} from "./chunk-W6D2D767.js";
+} from "./chunk-4YD6566T.js";
 import {
   ChargeRequestSchema,
   CredentialPayloadSchema,
   INTENT,
+  INTENT_ID_META_KEY,
   METHOD_NAME,
   atumEscrowChargeMethod
-} from "./chunk-2MWWLU75.js";
+} from "./chunk-Z3AUNEU5.js";
 export {
   ChargeRequestSchema,
   CredentialPayloadSchema,
   INTENT,
+  INTENT_ID_META_KEY,
   METHOD_NAME,
+  PaymentRejectedError,
+  SettlementFailedError,
+  SettlementPendingError,
   atumEscrowChargeMethod,
+  buildChargeChallenge,
   buildChargeRequest,
   corridorFromDefaults,
+  isPaymentRejected,
+  isSettlementFailed,
+  isSettlementPending,
   registerServer,
   validateCorridor
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atumlabs/mppx-atum-escrow",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "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
-};