@catena/sdk 0.1.0 → 0.4.0

package/dist/{client-Cm2wNUuB.d.mts → client-B_Gi0aqH.d.mts}

@@ -152,8 +152,15 @@ declare const accountBalanceResponseSchema: v.ObjectSchema<{
     readonly asset_id: v.StringSchema<undefined>;
   }, undefined>;
   /**
-   * `available` (what a send is checked against) is `total` minus reserved
-   * funds. Absent only from API deployments that predate the field.
+   * `available` is the most one payment from this account can move: every
+   * network it may use together where a plan carries the payment across
+   * them, otherwise the balance on the one network that payment binds, or
+   * the largest of them while that network holds nothing yet. It is zero
+   * while the account is not active, and zero when the only network the
+   * account holds is one agents may not use. A transfer to a Catena
+   * account still binds one network, so a plan's figure can be more than
+   * such a transfer accepts. Absent only from API deployments that predate
+   * these fields.
    */
   readonly balances: v.OptionalSchema<v.ObjectSchema<{
     readonly total: v.ObjectSchema<{
@@ -178,6 +185,41 @@ declare const accountBalanceResponseSchema: v.ObjectSchema<{
        */
       readonly asset_id: v.StringSchema<undefined>;
     }, undefined>;
+    /**
+     * `total` and `available` for each network that the account holds and
+     * agents may use. The entries can add up to less than `balances.total`,
+     * which also counts a network agents may not use, and their `available`
+     * can add up to more than `balances.available`, which one payment binds
+     * to one network. Every `available` is zero while the account is not
+     * active. An empty array means no network the account holds is open to
+     * agents. Absent until the account's money is split by network,
+     * and from API deployments that predate the field.
+     */
+    readonly byNetwork: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly network: v.StringSchema<undefined>;
+      readonly total: v.ObjectSchema<{
+        /**
+         * Decimal string in the asset's major unit: "12.50" is $12.50. Never cents or
+         * atomic units.
+         */
+        readonly amount: v.StringSchema<undefined>;
+        /**
+         * Asset identifier, e.g. "USD".
+         */
+        readonly asset_id: v.StringSchema<undefined>;
+      }, undefined>;
+      readonly available: v.ObjectSchema<{
+        /**
+         * Decimal string in the asset's major unit: "12.50" is $12.50. Never cents or
+         * atomic units.
+         */
+        readonly amount: v.StringSchema<undefined>;
+        /**
+         * Asset identifier, e.g. "USD".
+         */
+        readonly asset_id: v.StringSchema<undefined>;
+      }, undefined>;
+    }, undefined>, undefined>, undefined>;
   }, undefined>, undefined>;
 }, undefined>;
 type AccountBalanceResponse = v.InferOutput<typeof accountBalanceResponseSchema>;
@@ -222,6 +264,10 @@ declare const accountTransactionsResponseSchema: v.ObjectSchema<{
       readonly asset_id: v.StringSchema<undefined>;
     }, undefined>;
     readonly currency: v.StringSchema<undefined>;
+    /**
+     * On-chain network, absent for fiat and older transactions.
+     */
+    readonly network: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly counterpartyName: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly method: v.OptionalSchema<v.GenericSchema<string, ExtensibleString<readonly ["ach", "wire", "on-chain"]>>, undefined>;
     readonly memo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
@@ -267,8 +313,19 @@ type AccountDepositAddressResponse = v.InferOutput<typeof accountDepositAddressR
  * or asset added server-side never becomes a compile-time wall for an older
  * SDK. Response schemas parse plain strings for the same reason.
  */
-type OnchainNetworkInput = "base" | "base-sepolia" | (string & {});
+type OnchainNetworkInput = "base" | "base-sepolia" | "arc" | (string & {});
 type OnchainAssetInput = "usdc" | (string & {});
+declare const walletCounterpartyRailSchema: v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"wallet", undefined>;
+  readonly walletAddress: v.CustomSchema<`0x${string}`, undefined>;
+  readonly network: v.CustomSchema<OnchainNetworkInput, undefined>;
+}, undefined>;
+/**
+ * Catena wallet rail returned for deliberate counterparty recovery. It can be
+ * passed directly as `create_counterparty`'s `rail` after the caller chooses a
+ * name and confirms the recipient.
+ */
+type WalletCounterpartyRail = v.InferOutput<typeof walletCounterpartyRailSchema>;
 type AccountDepositAddressParams = {
   network: OnchainNetworkInput;
   asset: OnchainAssetInput;
@@ -276,8 +333,11 @@ type AccountDepositAddressParams = {
 /**
  * Rails are modeled tolerantly rather than as a variant on `type`: each
  * field is present only on the rail types it applies to (wallet rails carry
- * `walletAddress`/`network`, bank rails carry `bankName`/`accountNumber`),
- * and a server that later adds a new rail type must not break older clients.
+ * `walletAddress` and may carry `network`; bank rails carry
+ * `bankName`/`accountNumber`), and a server that later adds a new rail type
+ * must not break older clients. A wallet rail omits `network` when its
+ * configured destination is unavailable to the agent; it cannot receive an
+ * agent send until that configuration or the organization's capability changes.
  */
 declare const counterpartySchema: v.ObjectSchema<{
   readonly id: v.StringSchema<undefined>;
@@ -331,15 +391,68 @@ declare const counterpartiesResponseSchema: v.ObjectSchema<{
 type CounterpartiesResponse = v.InferOutput<typeof counterpartiesResponseSchema>;
 type CounterpartiesParams = {
   /**
-   * Only counterparties with a wallet rail at this address.
+   * Only counterparties that own this wallet address.
    */
   address?: `0x${string}` | undefined;
   /**
-   * Only counterparties with a wallet rail on this network.
+   * Only counterparties that own a wallet address in this network class.
+   * This does not promise that a payment can settle on the queried network.
    */
   network?: OnchainNetworkInput | undefined;
 };
 declare const INTENT_ACTION_TYPES: readonly ["send", "transfer", "create_counterparty", "request_counterparty_details", "x402", "mpp", "policy_override"];
+/**
+ * Present on a send that crosses chains: the counterparty wallet sits on the
+ * other side of the Base and Arc lane and the account had no balance to pay
+ * it there, so the first signature burned the amount toward the account's own
+ * address on the destination. `nextStep` is the whole contract: `wait` and
+ * poll while the crossing runs, `continue` when `continueIntent` is due,
+ * `done` once the counterparty was paid, `blocked` when an operator must
+ * step in. `state` walks `burning`, `attesting`, `minting`, `ready`,
+ * `delivering`, `delivered`; `failed` and `manual_review` are terminal.
+ */
+declare const CROSS_CHAIN_STATES: readonly ["burning", "attesting", "minting", "ready", "delivering", "delivered", "failed", "manual_review"];
+declare const CROSS_CHAIN_NEXT_STEPS: readonly ["wait", "continue", "done", "blocked"];
+declare const crossChainSendSchema: v.ObjectSchema<{
+  readonly id: v.StringSchema<undefined>;
+  readonly sourceNetwork: v.StringSchema<undefined>;
+  readonly destinationNetwork: v.StringSchema<undefined>;
+  readonly state: v.GenericSchema<string, ExtensibleString<readonly ["burning", "attesting", "minting", "ready", "delivering", "delivered", "failed", "manual_review"]>>;
+  readonly nextStep: v.GenericSchema<string, ExtensibleString<readonly ["wait", "continue", "done", "blocked"]>>;
+  readonly readyAt: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>;
+  readonly deliveredAt: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>;
+  readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+type CrossChainSend = v.InferOutput<typeof crossChainSendSchema>;
+declare const MOVEMENT_NEXT_STEPS: readonly ["wait", "continue", "done", "blocked"];
+/**
+ * Present on a payment carried by a movement plan.
+ *
+ * `nextStep` is what the payment is waiting for, which `status` cannot say on
+ * its own: a payment an admin is signing and one whose signature is already in
+ * flight are both "processing".
+ *
+ * - "wait" — nothing to do here. A person is deciding the payment, or has
+ *   approved it and an admin is finishing it. Read it again with
+ *   getIntent(...). If you restarted before signing a payment nobody had to
+ *   approve, send the original request again on the same idempotency key.
+ *   Within about five minutes of the first send it answers
+ *   `movement_authorization_in_progress`; after that it hands the payment back
+ *   for you to sign.
+ * - "done" — the payment completed.
+ * - "blocked" — it ended without paying. Read `reasons` for why; it is empty when
+ *   an approval lapsed.
+ *
+ * A payment a person has to approve is never handed back to you to finish:
+ * "continue" belongs to a send that crossed chains and is not an answer this
+ * field gives. It stays in the list because both fields are parsed against one
+ * vocabulary.
+ */
+declare const movementSchema: v.ObjectSchema<{
+  readonly planId: v.StringSchema<undefined>;
+  readonly nextStep: v.GenericSchema<string, ExtensibleString<readonly ["wait", "continue", "done", "blocked"]>>;
+}, undefined>;
+type Movement = v.InferOutput<typeof movementSchema>;
 declare const wireIntentResultSchema: v.ObjectSchema<{
   readonly id: v.StringSchema<undefined>;
   /**
@@ -352,11 +465,16 @@ declare const wireIntentResultSchema: v.ObjectSchema<{
    * Disposition of the intent:
    *
    * - "pending" — accepted but not yet executing, typically parked for a human
-   *   approval; `reasons` says why and `expiresAt` when it lapses.
+   *   approval; `reasons` says why and `expiresAt` when it lapses. A client
+   *   with no registered signing key has every wallet payment parked, whatever
+   *   the amount, and `reasons` carries `agent_signer_not_registered` (or
+   *   `operator_signature_required` for a payment with no `movement`).
    * - "processing" — accepted and in progress. Executing intents advance on their
    *   own; poll `getIntent`. An approved MPP or x402 payment instead rests here
    *   until the paid request is re-run — polling never advances it — and
-   *   `expiresAt` is when that grant lapses.
+   *   `expiresAt` is when that grant lapses. A payment a person approved also
+   *   rests here while an admin signs it, and `movement.nextStep` reads "wait"
+   *   until it is done or blocked.
    * - "completed" — the action succeeded: money moved for send and transfer; for
    *   MPP and x402 the payment authorization was delivered
    *   (`data.paymentCredential.value`), with on-chain settlement verified
@@ -396,6 +514,27 @@ declare const wireIntentResultSchema: v.ObjectSchema<{
   readonly metadata: v.OptionalSchema<v.ObjectSchema<{
     readonly dataUrl: v.NullableSchema<v.StringSchema<undefined>, undefined>;
   }, undefined>, undefined>;
+  /**
+   * Present on a send that crosses chains. See `CrossChainSend`.
+   */
+  readonly crossChain: v.OptionalSchema<v.ObjectSchema<{
+    readonly id: v.StringSchema<undefined>;
+    readonly sourceNetwork: v.StringSchema<undefined>;
+    readonly destinationNetwork: v.StringSchema<undefined>;
+    readonly state: v.GenericSchema<string, ExtensibleString<readonly ["burning", "attesting", "minting", "ready", "delivering", "delivered", "failed", "manual_review"]>>;
+    readonly nextStep: v.GenericSchema<string, ExtensibleString<readonly ["wait", "continue", "done", "blocked"]>>;
+    readonly readyAt: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>;
+    readonly deliveredAt: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>, undefined>;
+    readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+  }, undefined>, undefined>;
+  /**
+   * Present on a payment carried by a movement plan, and absent from a server
+   * that has not deployed them. See `Movement`.
+   */
+  readonly movement: v.OptionalSchema<v.ObjectSchema<{
+    readonly planId: v.StringSchema<undefined>;
+    readonly nextStep: v.GenericSchema<string, ExtensibleString<readonly ["wait", "continue", "done", "blocked"]>>;
+  }, undefined>, undefined>;
   readonly nextAction: v.OptionalSchema<v.ObjectSchema<{
     readonly type: v.LiteralSchema<"submit_stamp", undefined>;
     readonly signingRequestId: v.StringSchema<undefined>;
@@ -409,6 +548,24 @@ declare const wireIntentResultSchema: v.ObjectSchema<{
       readonly expiresAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
       readonly prepareToken: v.StringSchema<undefined>;
     }, undefined>;
+    /**
+     * Present when the approval covers a movement plan, whose one signature
+     * authorizes several digests at once. It carries what each of those digests
+     * commits to, so the signer can rebuild them rather than stamp bytes it has
+     * not read.
+     */
+    readonly movement: v.OptionalSchema<v.ObjectSchema<{
+      readonly planId: v.StringSchema<undefined>;
+      readonly signerAddress: v.StringSchema<undefined>;
+      readonly digests: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+      readonly instructions: v.ArraySchema<v.LooseObjectSchema<{
+        readonly kind: v.StringSchema<undefined>;
+        readonly network: v.StringSchema<undefined>;
+        readonly signerAddress: v.StringSchema<undefined>;
+        readonly digest: v.StringSchema<undefined>;
+        readonly payload: v.RecordSchema<v.StringSchema<undefined>, v.UnknownSchema, undefined>;
+      }, undefined>, undefined>;
+    }, undefined>, undefined>;
   }, undefined>, undefined>;
 }, undefined>;
 type WireIntentResult = v.InferOutput<typeof wireIntentResultSchema>;
@@ -631,7 +788,7 @@ declare const mppActionSchema: v.ObjectSchema<{
  */
 type MppAction = v.InferOutput<typeof mppActionSchema>;
 declare const POLICY_OVERRIDE_CAPABILITIES: readonly ["send", "transfer"];
-declare const intentActionSchema: v.UnionSchema<[v.ObjectSchema<{
+declare const intentActionSchema: v.UnionSchema<[v.VariantSchema<"method", [v.ObjectSchema<{
   readonly type: v.LiteralSchema<"send", undefined>;
   /**
    * Omit when the current policy allows sends from exactly one account.
@@ -647,10 +804,67 @@ declare const intentActionSchema: v.UnionSchema<[v.ObjectSchema<{
    * Decimal USD string: "12.50" is $12.50. Never cents or atomic units.
    */
   readonly amount: v.StringSchema<undefined>;
-  readonly method: v.PicklistSchema<readonly ["ach", "wire", "on-chain"], undefined>;
+  /**
+   * Internal note stored in Catena.
+   */
+  readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly method: v.LiteralSchema<"ach", undefined>;
+  /**
+   * Reference sent with the ACH payment.
+   */
   readonly memo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"send", undefined>;
+  /**
+   * Omit when the current policy allows sends from exactly one account.
+   * Zero or multiple send accounts require a policy change or an explicit id.
+   */
+  readonly accountId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+  /**
+   * Id of one entry in a counterparty's `rails` array (from
+   * `listCounterparties`) — not the counterparty id itself.
+   */
+  readonly counterpartyRailId: v.StringSchema<undefined>;
+  /**
+   * Decimal USD string: "12.50" is $12.50. Never cents or atomic units.
+   */
+  readonly amount: v.StringSchema<undefined>;
+  /**
+   * Internal note stored in Catena.
+   */
   readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly method: v.LiteralSchema<"wire", undefined>;
+  /**
+   * Reference sent with the wire payment.
+   */
+  readonly memo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
 }, undefined>, v.ObjectSchema<{
+  readonly type: v.LiteralSchema<"send", undefined>;
+  /**
+   * Omit when the current policy allows sends from exactly one account.
+   * Zero or multiple send accounts require a policy change or an explicit id.
+   */
+  readonly accountId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
+  /**
+   * Id of one entry in a counterparty's `rails` array (from
+   * `listCounterparties`) — not the counterparty id itself.
+   */
+  readonly counterpartyRailId: v.StringSchema<undefined>;
+  /**
+   * Decimal USD string: "12.50" is $12.50. Never cents or atomic units.
+   */
+  readonly amount: v.StringSchema<undefined>;
+  /**
+   * Internal note stored in Catena.
+   */
+  readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+  readonly method: v.LiteralSchema<"on-chain", undefined>;
+  /**
+   * @deprecated Not sent to the blockchain. Use `description` for an internal
+   *   note.
+   */
+  readonly memo: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>], undefined>, v.ObjectSchema<{
   readonly type: v.LiteralSchema<"transfer", undefined>;
   readonly accountId: v.StringSchema<undefined>;
   readonly toAccountId: v.StringSchema<undefined>;
@@ -912,12 +1126,19 @@ type IntentAction = v.InferOutput<typeof intentActionSchema>;
  * Non-OK API response. `code` is the API's stable error code — branch on it,
  * not on message prose. The code is also embedded in the message so hosts
  * that only print `error.message` still surface it.
+ * Field explanations are included in the message and preserved on `fields`.
  */
 declare class ApiError extends Error {
   readonly status: number;
   readonly code: string | undefined;
   readonly details: Record<string, unknown> | undefined;
-  constructor(status: number, message: string, code?: string, details?: Record<string, unknown>);
+  /**
+   * Validation explanations keyed by request field path, when present.
+   * The `request` key represents a request-wide issue rather than a field;
+   * its explanation appears in `message` without a field-path prefix.
+   */
+  readonly fields: Record<string, string> | undefined;
+  constructor(status: number, message: string, code?: string, details?: Record<string, unknown>, fields?: Record<string, string>);
 }
 /**
  * An HTTP exchange exceeded the client's configured deadline. The deadline
@@ -1055,6 +1276,42 @@ declare class CatenaClient {
     idempotencyKey?: string;
   }): Promise<IntentResult>;
   getIntent(id: string): Promise<IntentResult>;
+  /**
+   * Finish a send that crossed chains, once `crossChain.nextStep` reads
+   * "continue": prepares and signs the send to the counterparty on the
+   * destination network. Gas is paid by Catena. A destination the provider does
+   * not sponsor yet is refused with `wallet_send_action_not_yet_enabled`; the
+   * intent stays at "continue" and the call can be made again later.
+   *
+   * A payment a person had to approve is NOT continued here. Once it is
+   * approved an admin finishes it, and this call refuses it with
+   * `movement_admin_completes_payment`; `movement.nextStep` stays "wait" and
+   * resolves to "done" or "blocked" on its own. Resending the original request
+   * does not finish it either — that hands back the payment's intent, or tells
+   * you to read it, never a new signature.
+   *
+   * It continues the same intent, so no second intent, spend or approval is
+   * involved, and the result is the intent view after the signature, the same
+   * shape `getIntent(...)` serves.
+   *
+   * `action` is the one you originally submitted. It is compared only against
+   * a movement stamp, and a continuation now only finishes a send that crossed
+   * chains, which carries none, so today it is accepted and not checked.
+   *
+   * Errors: failures in the continue exchange propagate unwrapped — `ApiError`
+   * for non-OK responses (the refusals above among them), `TimeoutError` when
+   * the exchange deadline expires, and raw transport, signing and
+   * response-parsing errors otherwise. Once the continuation is prepared,
+   * failures while stamping or signing it surface as `IntentSubmitError` with
+   * outcome `"not-submitted"`; from the first dispatched byte they surface
+   * with outcome `"unknown"`, and `getIntent(...)` is the reconciliation
+   * handle.
+   */
+  continueIntent(params: {
+    intentId: string;
+    idempotencyKey?: string;
+    action?: IntentAction;
+  }): Promise<IntentResult>;
   /**
    * Permanently sever this agent link: the server revokes the link's active
    * auth keys, so every request signed with this credential fails from then
@@ -1093,4 +1350,4 @@ declare class CatenaClient {
  */
 declare function createCatenaClient(options?: CatenaClientOptions): CatenaClient;
 //#endregion
-export { IntentResult as A, Policy as B, COUNTERPARTY_RULE_MODES as C, ExtensibleString as D, Counterparty as E, OnchainNetworkInput as F, X402Resource as G, SendMethod as H, POLICY_CAPABILITIES as I, X402SignedReceipt as J, AppInfo as K, POLICY_OVERRIDE_CAPABILITIES as L, MppChallenge as M, MppResource as N, INTENT_ACTION_TYPES as O, OnchainAssetInput as P, POLICY_RULE_ACTIONS as R, COUNTERPARTY_ACTIONS as S, CounterpartiesResponse as T, X402Authorization as U, SEND_METHODS as V, X402PaymentRequirements as W, AccountDepositAddressResponse as _, IntentSubmitError as a, AccountsResponse as b, ACCOUNT_AGGREGATION_SCOPES as c, ACCOUNT_TRANSACTION_MOVEMENT_STATUSES as d, ACCOUNT_TRANSACTION_STATUSES as f, AccountDepositAddressParams as g, AccountBalanceResponse as h, FetchLike as i, MppAction as j, IntentAction as k, ACCOUNT_DEPOSIT_ADDRESS_SOURCES as l, ACTOR_AGGREGATION_SCOPES as m, CatenaClient as n, TimeoutError as o, ACCOUNT_TRANSACTION_TYPES as p, X402SignedOffer as q, CatenaClientOptions as r, createCatenaClient as s, ApiError as t, ACCOUNT_TRANSACTION_METHODS as u, AccountTransactionsParams as v, CounterpartiesParams as w, Agent as x, AccountTransactionsResponse as y, POLICY_RULE_TYPES as z };
+export { X402SignedOffer as $, ExtensibleString as A, OnchainNetworkInput as B, COUNTERPARTY_RULE_MODES as C, CounterpartiesResponse as D, CounterpartiesParams as E, Movement as F, Policy as G, POLICY_OVERRIDE_CAPABILITIES as H, MppAction as I, WalletCounterpartyRail as J, SEND_METHODS as K, MppChallenge as L, IntentAction as M, IntentResult as N, Counterparty as O, MOVEMENT_NEXT_STEPS as P, AppInfo as Q, MppResource as R, COUNTERPARTY_ACTIONS as S, CROSS_CHAIN_STATES as T, POLICY_RULE_ACTIONS as U, POLICY_CAPABILITIES as V, POLICY_RULE_TYPES as W, X402PaymentRequirements as X, X402Authorization as Y, X402Resource as Z, AccountDepositAddressResponse as _, IntentSubmitError as a, AccountsResponse as b, ACCOUNT_AGGREGATION_SCOPES as c, ACCOUNT_TRANSACTION_MOVEMENT_STATUSES as d, X402SignedReceipt as et, ACCOUNT_TRANSACTION_STATUSES as f, AccountDepositAddressParams as g, AccountBalanceResponse as h, FetchLike as i, INTENT_ACTION_TYPES as j, CrossChainSend as k, ACCOUNT_DEPOSIT_ADDRESS_SOURCES as l, ACTOR_AGGREGATION_SCOPES as m, CatenaClient as n, TimeoutError as o, ACCOUNT_TRANSACTION_TYPES as p, SendMethod as q, CatenaClientOptions as r, createCatenaClient as s, ApiError as t, ACCOUNT_TRANSACTION_METHODS as u, AccountTransactionsParams as v, CROSS_CHAIN_NEXT_STEPS as w, Agent as x, AccountTransactionsResponse as y, OnchainAssetInput as z };

package/dist/client.d.mts

@@ -1,3 +1,3 @@
 import { t as InvalidKeyError } from "./keypair-BjMJtI3-.mjs";
-import { A as IntentResult, B as Policy, C as COUNTERPARTY_RULE_MODES, D as ExtensibleString, E as Counterparty, F as OnchainNetworkInput, G as X402Resource, H as SendMethod, I as POLICY_CAPABILITIES, J as X402SignedReceipt, K as AppInfo, L as POLICY_OVERRIDE_CAPABILITIES, M as MppChallenge, N as MppResource, O as INTENT_ACTION_TYPES, P as OnchainAssetInput, R as POLICY_RULE_ACTIONS, S as COUNTERPARTY_ACTIONS, T as CounterpartiesResponse, U as X402Authorization, V as SEND_METHODS, W as X402PaymentRequirements, _ as AccountDepositAddressResponse, a as IntentSubmitError, b as AccountsResponse, c as ACCOUNT_AGGREGATION_SCOPES, d as ACCOUNT_TRANSACTION_MOVEMENT_STATUSES, f as ACCOUNT_TRANSACTION_STATUSES, g as AccountDepositAddressParams, h as AccountBalanceResponse, i as FetchLike, j as MppAction, k as IntentAction, l as ACCOUNT_DEPOSIT_ADDRESS_SOURCES, m as ACTOR_AGGREGATION_SCOPES, n as CatenaClient, o as TimeoutError, p as ACCOUNT_TRANSACTION_TYPES, q as X402SignedOffer, r as CatenaClientOptions, s as createCatenaClient, t as ApiError, u as ACCOUNT_TRANSACTION_METHODS, v as AccountTransactionsParams, w as CounterpartiesParams, x as Agent, y as AccountTransactionsResponse, z as POLICY_RULE_TYPES } from "./client-Cm2wNUuB.mjs";
-export { ACCOUNT_AGGREGATION_SCOPES, ACCOUNT_DEPOSIT_ADDRESS_SOURCES, ACCOUNT_TRANSACTION_METHODS, ACCOUNT_TRANSACTION_MOVEMENT_STATUSES, ACCOUNT_TRANSACTION_STATUSES, ACCOUNT_TRANSACTION_TYPES, ACTOR_AGGREGATION_SCOPES, type AccountBalanceResponse, type AccountDepositAddressParams, type AccountDepositAddressResponse, type AccountTransactionsParams, type AccountTransactionsResponse, type AccountsResponse, type Agent, ApiError, type AppInfo, COUNTERPARTY_ACTIONS, COUNTERPARTY_RULE_MODES, type CatenaClient, CatenaClientOptions, type CounterpartiesParams, type CounterpartiesResponse, type Counterparty, type ExtensibleString, FetchLike, INTENT_ACTION_TYPES, type IntentAction, type IntentResult, IntentSubmitError, InvalidKeyError, type MppAction, type MppChallenge, type MppResource, type OnchainAssetInput, type OnchainNetworkInput, POLICY_CAPABILITIES, POLICY_OVERRIDE_CAPABILITIES, POLICY_RULE_ACTIONS, POLICY_RULE_TYPES, type Policy, SEND_METHODS, type SendMethod, TimeoutError, type X402Authorization, type X402PaymentRequirements, type X402Resource, type X402SignedOffer, type X402SignedReceipt, createCatenaClient };
+import { $ as X402SignedOffer, A as ExtensibleString, B as OnchainNetworkInput, C as COUNTERPARTY_RULE_MODES, D as CounterpartiesResponse, E as CounterpartiesParams, F as Movement, G as Policy, H as POLICY_OVERRIDE_CAPABILITIES, I as MppAction, J as WalletCounterpartyRail, K as SEND_METHODS, L as MppChallenge, M as IntentAction, N as IntentResult, O as Counterparty, P as MOVEMENT_NEXT_STEPS, Q as AppInfo, R as MppResource, S as COUNTERPARTY_ACTIONS, T as CROSS_CHAIN_STATES, U as POLICY_RULE_ACTIONS, V as POLICY_CAPABILITIES, W as POLICY_RULE_TYPES, X as X402PaymentRequirements, Y as X402Authorization, Z as X402Resource, _ as AccountDepositAddressResponse, a as IntentSubmitError, b as AccountsResponse, c as ACCOUNT_AGGREGATION_SCOPES, d as ACCOUNT_TRANSACTION_MOVEMENT_STATUSES, et as X402SignedReceipt, f as ACCOUNT_TRANSACTION_STATUSES, g as AccountDepositAddressParams, h as AccountBalanceResponse, i as FetchLike, j as INTENT_ACTION_TYPES, k as CrossChainSend, l as ACCOUNT_DEPOSIT_ADDRESS_SOURCES, m as ACTOR_AGGREGATION_SCOPES, n as CatenaClient, o as TimeoutError, p as ACCOUNT_TRANSACTION_TYPES, q as SendMethod, r as CatenaClientOptions, s as createCatenaClient, t as ApiError, u as ACCOUNT_TRANSACTION_METHODS, v as AccountTransactionsParams, w as CROSS_CHAIN_NEXT_STEPS, x as Agent, y as AccountTransactionsResponse, z as OnchainAssetInput } from "./client-B_Gi0aqH.mjs";
+export { ACCOUNT_AGGREGATION_SCOPES, ACCOUNT_DEPOSIT_ADDRESS_SOURCES, ACCOUNT_TRANSACTION_METHODS, ACCOUNT_TRANSACTION_MOVEMENT_STATUSES, ACCOUNT_TRANSACTION_STATUSES, ACCOUNT_TRANSACTION_TYPES, ACTOR_AGGREGATION_SCOPES, type AccountBalanceResponse, type AccountDepositAddressParams, type AccountDepositAddressResponse, type AccountTransactionsParams, type AccountTransactionsResponse, type AccountsResponse, type Agent, ApiError, type AppInfo, COUNTERPARTY_ACTIONS, COUNTERPARTY_RULE_MODES, CROSS_CHAIN_NEXT_STEPS, CROSS_CHAIN_STATES, type CatenaClient, CatenaClientOptions, type CounterpartiesParams, type CounterpartiesResponse, type Counterparty, type CrossChainSend, type ExtensibleString, FetchLike, INTENT_ACTION_TYPES, type IntentAction, type IntentResult, IntentSubmitError, InvalidKeyError, MOVEMENT_NEXT_STEPS, type Movement, type MppAction, type MppChallenge, type MppResource, type OnchainAssetInput, type OnchainNetworkInput, POLICY_CAPABILITIES, POLICY_OVERRIDE_CAPABILITIES, POLICY_RULE_ACTIONS, POLICY_RULE_TYPES, type Policy, SEND_METHODS, type SendMethod, TimeoutError, type WalletCounterpartyRail, type X402Authorization, type X402PaymentRequirements, type X402Resource, type X402SignedOffer, type X402SignedReceipt, createCatenaClient };

package/dist/client.mjs

@@ -1,3 +1,3 @@
 import { InvalidKeyError } from "./keypair.mjs";
-import { _ as POLICY_RULE_ACTIONS, a as ACCOUNT_AGGREGATION_SCOPES, c as ACCOUNT_TRANSACTION_MOVEMENT_STATUSES, d as ACTOR_AGGREGATION_SCOPES, f as COUNTERPARTY_ACTIONS, g as POLICY_OVERRIDE_CAPABILITIES, h as POLICY_CAPABILITIES, i as createCatenaClient, l as ACCOUNT_TRANSACTION_STATUSES, m as INTENT_ACTION_TYPES, n as IntentSubmitError, o as ACCOUNT_DEPOSIT_ADDRESS_SOURCES, p as COUNTERPARTY_RULE_MODES, r as TimeoutError, s as ACCOUNT_TRANSACTION_METHODS, t as ApiError, u as ACCOUNT_TRANSACTION_TYPES, v as POLICY_RULE_TYPES, y as SEND_METHODS } from "./client-CHZMO00P.mjs";
-export { ACCOUNT_AGGREGATION_SCOPES, ACCOUNT_DEPOSIT_ADDRESS_SOURCES, ACCOUNT_TRANSACTION_METHODS, ACCOUNT_TRANSACTION_MOVEMENT_STATUSES, ACCOUNT_TRANSACTION_STATUSES, ACCOUNT_TRANSACTION_TYPES, ACTOR_AGGREGATION_SCOPES, ApiError, COUNTERPARTY_ACTIONS, COUNTERPARTY_RULE_MODES, INTENT_ACTION_TYPES, IntentSubmitError, InvalidKeyError, POLICY_CAPABILITIES, POLICY_OVERRIDE_CAPABILITIES, POLICY_RULE_ACTIONS, POLICY_RULE_TYPES, SEND_METHODS, TimeoutError, createCatenaClient };
+import { S as SEND_METHODS, _ as MOVEMENT_NEXT_STEPS, a as ACCOUNT_AGGREGATION_SCOPES, b as POLICY_RULE_ACTIONS, c as ACCOUNT_TRANSACTION_MOVEMENT_STATUSES, d as ACTOR_AGGREGATION_SCOPES, f as COUNTERPARTY_ACTIONS, g as INTENT_ACTION_TYPES, h as CROSS_CHAIN_STATES, i as createCatenaClient, l as ACCOUNT_TRANSACTION_STATUSES, m as CROSS_CHAIN_NEXT_STEPS, n as IntentSubmitError, o as ACCOUNT_DEPOSIT_ADDRESS_SOURCES, p as COUNTERPARTY_RULE_MODES, r as TimeoutError, s as ACCOUNT_TRANSACTION_METHODS, t as ApiError, u as ACCOUNT_TRANSACTION_TYPES, v as POLICY_CAPABILITIES, x as POLICY_RULE_TYPES, y as POLICY_OVERRIDE_CAPABILITIES } from "./client-BSYVYJGm.mjs";
+export { ACCOUNT_AGGREGATION_SCOPES, ACCOUNT_DEPOSIT_ADDRESS_SOURCES, ACCOUNT_TRANSACTION_METHODS, ACCOUNT_TRANSACTION_MOVEMENT_STATUSES, ACCOUNT_TRANSACTION_STATUSES, ACCOUNT_TRANSACTION_TYPES, ACTOR_AGGREGATION_SCOPES, ApiError, COUNTERPARTY_ACTIONS, COUNTERPARTY_RULE_MODES, CROSS_CHAIN_NEXT_STEPS, CROSS_CHAIN_STATES, INTENT_ACTION_TYPES, IntentSubmitError, InvalidKeyError, MOVEMENT_NEXT_STEPS, POLICY_CAPABILITIES, POLICY_OVERRIDE_CAPABILITIES, POLICY_RULE_ACTIONS, POLICY_RULE_TYPES, SEND_METHODS, TimeoutError, createCatenaClient };

package/dist/movements.d.mts

@@ -0,0 +1,139 @@
+//#region src/movements.d.ts
+/**
+ * Independent review of a movement approval, before anything is stamped.
+ *
+ * A movement is authorized by one signature over a batch of pre-hashed
+ * digests. A digest cannot be read, so a signing policy cannot constrain what
+ * it commits to: the only content control is the signer rebuilding every
+ * digest from the fields it is said to cover and refusing when they disagree.
+ * The console does this before it prompts for a passkey. An agent holds the
+ * same authority with a different credential, so it does the same thing here
+ * rather than stamping a body it has not checked.
+ *
+ * The check is local: no network, no server answer to trust. It proves that the
+ * request would sign exactly the digests the approval lists, that each of them
+ * is the payload shown for it, that every payload acts on the approval's own
+ * wallet and on the network it is labelled with, and that a delegation names
+ * the one contract a wallet here is allowed to hand itself to.
+ *
+ * It also refuses any payload that would move the network's own token, which
+ * is the one amount every kind states in a field rather than inside call data.
+ * On a chain whose gas token is the asset being moved, that value is a payment
+ * nothing else in the approval describes.
+ *
+ * Given the caller's own amount it also proves the approval pays it, for the
+ * approvals where that can be known: a transfer authorization states its
+ * amount in a field the digest covers, so an approval built only from those is
+ * bound to the sum they deliver.
+ *
+ * What it does not prove is what a payload's call data does. A raw transaction
+ * and a batch execution carry their recipient and amount as encoded call data,
+ * which is reproduced but not decoded, and a payment can be built entirely
+ * from those -- so an approval carrying one is not bound to any amount at all.
+ * For those kinds the guarantee is that the bytes signed are the bytes shown,
+ * not that the bytes shown are a payment to anyone in particular. Binding them
+ * needs that call data decoded, which would mean recognising every contract
+ * and call shape a payment can use and refusing any built from one this client
+ * does not know yet; that is not attempted here.
+ *
+ * Requires the optional `viem` peer dependency; importing this module without
+ * viem installed fails with a module-not-found error naming it.
+ */
+/**
+ * One thing the approval would sign, with every field its digest commits to.
+ */
+export interface MovementInstructionReview {
+  /**
+   * What kind of signable material this is.
+   */
+  kind: string;
+  /**
+   * The network it acts on.
+   */
+  network: string;
+  /**
+   * The wallet that must sign it.
+   */
+  signerAddress: string;
+  /**
+   * The digest the approval carries for it.
+   */
+  digest: string;
+  /**
+   * The fields the digest commits to.
+   */
+  payload: Record<string, unknown>;
+}
+/**
+ * The approval as prepared, as it arrives on a `submit_stamp` next action.
+ */
+export interface PreparedMovement {
+  /**
+   * The wallet every instruction must name.
+   */
+  signerAddress: string;
+  /**
+   * Every digest the approval would sign, in order.
+   */
+  digests: readonly string[];
+  /**
+   * What each of those digests commits to.
+   */
+  instructions: readonly MovementInstructionReview[];
+  /**
+   * The provider request body that would be stamped.
+   */
+  body: string;
+}
+/**
+ * What the caller asked for, to check the approval against. Only the amount
+ * today: a counterparty rail is named by id rather than by address, and this
+ * client cannot resolve one locally, so the recipient stays unbound.
+ */
+export interface RequestedPayment {
+  /**
+   * The amount as the caller wrote it, in USDC.
+   */
+  amount: string;
+}
+export type MovementReviewVerdict = {
+  ok: true;
+} | {
+  ok: false;
+  reason: string;
+};
+/**
+ * Recompute an instruction's digest from the fields it says it covers, or
+ * `null` when the payload does not parse as its kind. A `null` is a refusal,
+ * never a pass.
+ */
+export declare function rebuildInstructionDigest(instruction: Pick<MovementInstructionReview, "kind" | "payload">): string | null;
+/**
+ * Whether a prepared movement may be stamped: every digest rebuilt from the
+ * fields it says it covers, every instruction naming the same signer and the
+ * network it actually signs on, no payload spending from another wallet, no
+ * delegation handing the wallet to an unrecognised contract, the approval
+ * listing exactly those digests, and the request body pinned to them and to
+ * that signer.
+ *
+ * Refuse on anything but `ok`. A reason describes what disagreed, and a
+ * disagreement means the body would sign something other than what it
+ * describes.
+ *
+ * No instruction may move the network's own token, which is the one amount
+ * every kind states in a field rather than inside call data.
+ *
+ * Pass `requested` to also check the approval against what the caller asked
+ * for. That binds only when every payload able to move value states its amount
+ * in a named field; an approval carrying one whose amount lives in call data
+ * is left unbound, because a sum over the rest would bind nothing.
+ *
+ * This checks that a payload is the one shown for its digest. It does not
+ * decode call data, so for kinds that carry their recipient and amount as
+ * encoded call data rather than as named fields, a passing verdict means the
+ * bytes signed are the bytes shown, not that they pay a particular party for a
+ * particular amount. The recipient is never bound: a counterparty rail is
+ * named by id, and this client cannot resolve one to an address on its own.
+ */
+export declare function verifyPreparedMovement(prepared: PreparedMovement, requested?: RequestedPayment): MovementReviewVerdict;
+//#endregion