uvd-x402-sdk 2.107.0 → 2.108.0

package/README.md

@@ -10,6 +10,8 @@ Users sign a message or transaction, and the Ultravioleta facilitator handles on
 
 ## Features
 
+**Arras NEAR escrow (v2.108.0):** offline local-key NEP-366 authorization, canonical Rust payment IDs and pull lifecycle helpers through `uvd-x402-sdk/near`. [Guide and agent example](docs/near-escrow.md). As of 2026-11-02 the facilitator advertises escrow only on testnet, and the SDK's escrow contract registry has no mainnet row yet.
+
 - **31 Networks**: EVM (19 including HashKey Chain, Arc, Scroll, SKALE Base, Robinhood Chain), Solana, Fogo, Stellar, NEAR, Algorand, Sui, XRP Ledger, Hedera (mainnet + testnet)
 - **Multi-Stablecoin**: USDC, EURC, AUSD, PYUSD, USDT, USDG (Robinhood Chain)
 - **x402 v1 & v2**: Protocol auto-detection; native Hedera supports v2/exact only

package/dist/providers/near/index.d.mts

@@ -1,5 +1,101 @@
 import { W as WalletAdapter, C as ChainConfig, P as PaymentInfo, X as X402Version } from '../../index-DARXHuQl.mjs';
 
+type NearEscrowNetwork = 'near:mainnet' | 'near:testnet';
+/** Numbers must be safe integers; use decimal strings or bigint for nanoseconds and u128. */
+type NearUnsigned = string | bigint | number;
+interface EscrowMsgParams {
+    operator_id: string;
+    receiver: string;
+    release_deadline: NearUnsigned;
+    reclaim_after: NearUnsigned;
+    fee_bps_max: number;
+    terms_hash: string;
+    salt: string;
+}
+interface PaymentIdParams extends EscrowMsgParams {
+    token: string;
+    payer: string;
+    amount: NearUnsigned;
+}
+interface NearLocalSigner {
+    readonly publicKey: Uint8Array;
+    /** Sign the NEP-366 SHA-256 digest directly, without a NEP-413 envelope. */
+    sign(digest: Uint8Array): Uint8Array | Promise<Uint8Array>;
+}
+interface NearEscrowDelegateOptions {
+    network: NearEscrowNetwork;
+    signer: NearLocalSigner;
+    senderId: string;
+    escrowContract: string;
+    /** The next access-key nonce, not the current nonce. */
+    nonce: NearUnsigned;
+    maxBlockHeight: NearUnsigned;
+    /** Gas units (1 TGas = 10^12), not a floating point TGas count. */
+    gas?: NearUnsigned;
+}
+interface EscrowAuthorizationOptions extends NearEscrowDelegateOptions {
+    token: string;
+    amount: NearUnsigned;
+    msg: EscrowMsgParams;
+}
+interface NearEscrowPayment {
+    x402Version: 2;
+    scheme: 'escrow';
+    network: NearEscrowNetwork;
+    payload: {
+        signedDelegateAction: string;
+    };
+}
+interface NearEscrowFunctionCall {
+    methodName: string;
+    args: string;
+    gas: NearUnsigned;
+    deposit: NearUnsigned;
+}
+interface NearEscrowDelegate {
+    senderId: string;
+    receiverId: string;
+    actions: NearEscrowFunctionCall[];
+    nonce: NearUnsigned;
+    maxBlockHeight: NearUnsigned;
+}
+declare const NEAR_ESCROW_MIN_GAS = 38000000000000n;
+declare const NEAR_ESCROW_MAX_GAS = 100000000000000n;
+declare const NEAR_ESCROW_TOKENS: Readonly<Record<NearEscrowNetwork, string>>;
+/**
+ * The Arras escrow deployments this SDK signs for, per network. Any other escrowContract is refused before the
+ * signer is called, for authorization and lifecycle alike: a signed delegate can be relayed by anyone, so a 402
+ * server must not be able to point it at its own account. Mainnet stays empty until its contract ships in a release.
+ */
+declare const NEAR_ESCROW_CONTRACTS: Readonly<Record<NearEscrowNetwork, readonly string[]>>;
+/** Canonical Arras JSON: field order, decimal-string timestamps, lowercase hex, no spaces. */
+declare function buildEscrowMsg(p: EscrowMsgParams): string;
+/** Exact Rust Borsh preimage, exposed for cross-language conformance. */
+declare function paymentIdPreimage(p: PaymentIdParams): Uint8Array;
+declare function computePaymentId(p: PaymentIdParams): string;
+/** A 32-byte Ed25519 seed, or a NEAR ed25519: base58 secret (seed + public key, 64 bytes). */
+declare function createNearLocalSigner(secret: Uint8Array | string): NearLocalSigner;
+/** Build the one allowed FT action. The contract must be in NEAR_ESCROW_CONTRACTS; the operator comes from trusted /supported configuration. */
+declare function buildEscrowAuthorizationDelegate(o: EscrowAuthorizationOptions): NearEscrowDelegate;
+/** Validate before signing, including strict byte binding to the expected canonical FT arguments. */
+declare function validateEscrowAuthorizationDelegate(d: NearEscrowDelegate, o: EscrowAuthorizationOptions): void;
+declare function signEscrowAuthorization(options: EscrowAuthorizationOptions): Promise<NearEscrowPayment>;
+type NearEscrowLifecycleMethod = 'release' | 'refund' | 'reclaim' | 'withdraw' | 'withdraw_for';
+declare function signEscrowLifecycle(options: NearEscrowDelegateOptions, method: NearEscrowLifecycleMethod, args?: {
+    payment_id?: string;
+    amount?: NearUnsigned | null;
+    account?: string;
+}): Promise<NearEscrowPayment>;
+declare const release: (o: NearEscrowDelegateOptions, paymentId: string, amount?: NearUnsigned | null) => Promise<NearEscrowPayment>;
+declare const refund: (o: NearEscrowDelegateOptions, paymentId: string) => Promise<NearEscrowPayment>;
+declare const reclaim: (o: NearEscrowDelegateOptions, paymentId: string) => Promise<NearEscrowPayment>;
+declare const withdraw: (o: NearEscrowDelegateOptions) => Promise<NearEscrowPayment>;
+declare const withdrawFor: (o: NearEscrowDelegateOptions, account: string) => Promise<NearEscrowPayment>;
+/** v2 boundary only: no budget wire format or signing is defined until Arras v2 supplies its vectors. */
+interface AuthorizeFromBudget {
+    authorizeFromBudget(request: unknown): Promise<NearEscrowPayment>;
+}
+
 /**
  * uvd-x402-sdk - NEAR Provider
  *
@@ -138,4 +234,4 @@ declare class NEARProvider implements WalletAdapter {
     private base58Encode;
 }
 
-export { NEARProvider, type WalletSelectorOptions, NEARProvider as default };
+export { type AuthorizeFromBudget, type EscrowAuthorizationOptions, type EscrowMsgParams, NEARProvider, NEAR_ESCROW_CONTRACTS, NEAR_ESCROW_MAX_GAS, NEAR_ESCROW_MIN_GAS, NEAR_ESCROW_TOKENS, type NearEscrowDelegate, type NearEscrowDelegateOptions, type NearEscrowFunctionCall, type NearEscrowLifecycleMethod, type NearEscrowNetwork, type NearEscrowPayment, type NearLocalSigner, type NearUnsigned, type PaymentIdParams, type WalletSelectorOptions, buildEscrowAuthorizationDelegate, buildEscrowMsg, computePaymentId, createNearLocalSigner, NEARProvider as default, paymentIdPreimage, reclaim, refund, release, signEscrowAuthorization, signEscrowLifecycle, validateEscrowAuthorizationDelegate, withdraw, withdrawFor };

package/dist/providers/near/index.d.ts

@@ -1,5 +1,101 @@
 import { W as WalletAdapter, C as ChainConfig, P as PaymentInfo, X as X402Version } from '../../index-DARXHuQl.js';
 
+type NearEscrowNetwork = 'near:mainnet' | 'near:testnet';
+/** Numbers must be safe integers; use decimal strings or bigint for nanoseconds and u128. */
+type NearUnsigned = string | bigint | number;
+interface EscrowMsgParams {
+    operator_id: string;
+    receiver: string;
+    release_deadline: NearUnsigned;
+    reclaim_after: NearUnsigned;
+    fee_bps_max: number;
+    terms_hash: string;
+    salt: string;
+}
+interface PaymentIdParams extends EscrowMsgParams {
+    token: string;
+    payer: string;
+    amount: NearUnsigned;
+}
+interface NearLocalSigner {
+    readonly publicKey: Uint8Array;
+    /** Sign the NEP-366 SHA-256 digest directly, without a NEP-413 envelope. */
+    sign(digest: Uint8Array): Uint8Array | Promise<Uint8Array>;
+}
+interface NearEscrowDelegateOptions {
+    network: NearEscrowNetwork;
+    signer: NearLocalSigner;
+    senderId: string;
+    escrowContract: string;
+    /** The next access-key nonce, not the current nonce. */
+    nonce: NearUnsigned;
+    maxBlockHeight: NearUnsigned;
+    /** Gas units (1 TGas = 10^12), not a floating point TGas count. */
+    gas?: NearUnsigned;
+}
+interface EscrowAuthorizationOptions extends NearEscrowDelegateOptions {
+    token: string;
+    amount: NearUnsigned;
+    msg: EscrowMsgParams;
+}
+interface NearEscrowPayment {
+    x402Version: 2;
+    scheme: 'escrow';
+    network: NearEscrowNetwork;
+    payload: {
+        signedDelegateAction: string;
+    };
+}
+interface NearEscrowFunctionCall {
+    methodName: string;
+    args: string;
+    gas: NearUnsigned;
+    deposit: NearUnsigned;
+}
+interface NearEscrowDelegate {
+    senderId: string;
+    receiverId: string;
+    actions: NearEscrowFunctionCall[];
+    nonce: NearUnsigned;
+    maxBlockHeight: NearUnsigned;
+}
+declare const NEAR_ESCROW_MIN_GAS = 38000000000000n;
+declare const NEAR_ESCROW_MAX_GAS = 100000000000000n;
+declare const NEAR_ESCROW_TOKENS: Readonly<Record<NearEscrowNetwork, string>>;
+/**
+ * The Arras escrow deployments this SDK signs for, per network. Any other escrowContract is refused before the
+ * signer is called, for authorization and lifecycle alike: a signed delegate can be relayed by anyone, so a 402
+ * server must not be able to point it at its own account. Mainnet stays empty until its contract ships in a release.
+ */
+declare const NEAR_ESCROW_CONTRACTS: Readonly<Record<NearEscrowNetwork, readonly string[]>>;
+/** Canonical Arras JSON: field order, decimal-string timestamps, lowercase hex, no spaces. */
+declare function buildEscrowMsg(p: EscrowMsgParams): string;
+/** Exact Rust Borsh preimage, exposed for cross-language conformance. */
+declare function paymentIdPreimage(p: PaymentIdParams): Uint8Array;
+declare function computePaymentId(p: PaymentIdParams): string;
+/** A 32-byte Ed25519 seed, or a NEAR ed25519: base58 secret (seed + public key, 64 bytes). */
+declare function createNearLocalSigner(secret: Uint8Array | string): NearLocalSigner;
+/** Build the one allowed FT action. The contract must be in NEAR_ESCROW_CONTRACTS; the operator comes from trusted /supported configuration. */
+declare function buildEscrowAuthorizationDelegate(o: EscrowAuthorizationOptions): NearEscrowDelegate;
+/** Validate before signing, including strict byte binding to the expected canonical FT arguments. */
+declare function validateEscrowAuthorizationDelegate(d: NearEscrowDelegate, o: EscrowAuthorizationOptions): void;
+declare function signEscrowAuthorization(options: EscrowAuthorizationOptions): Promise<NearEscrowPayment>;
+type NearEscrowLifecycleMethod = 'release' | 'refund' | 'reclaim' | 'withdraw' | 'withdraw_for';
+declare function signEscrowLifecycle(options: NearEscrowDelegateOptions, method: NearEscrowLifecycleMethod, args?: {
+    payment_id?: string;
+    amount?: NearUnsigned | null;
+    account?: string;
+}): Promise<NearEscrowPayment>;
+declare const release: (o: NearEscrowDelegateOptions, paymentId: string, amount?: NearUnsigned | null) => Promise<NearEscrowPayment>;
+declare const refund: (o: NearEscrowDelegateOptions, paymentId: string) => Promise<NearEscrowPayment>;
+declare const reclaim: (o: NearEscrowDelegateOptions, paymentId: string) => Promise<NearEscrowPayment>;
+declare const withdraw: (o: NearEscrowDelegateOptions) => Promise<NearEscrowPayment>;
+declare const withdrawFor: (o: NearEscrowDelegateOptions, account: string) => Promise<NearEscrowPayment>;
+/** v2 boundary only: no budget wire format or signing is defined until Arras v2 supplies its vectors. */
+interface AuthorizeFromBudget {
+    authorizeFromBudget(request: unknown): Promise<NearEscrowPayment>;
+}
+
 /**
  * uvd-x402-sdk - NEAR Provider
  *
@@ -138,4 +234,4 @@ declare class NEARProvider implements WalletAdapter {
     private base58Encode;
 }
 
-export { NEARProvider, type WalletSelectorOptions, NEARProvider as default };
+export { type AuthorizeFromBudget, type EscrowAuthorizationOptions, type EscrowMsgParams, NEARProvider, NEAR_ESCROW_CONTRACTS, NEAR_ESCROW_MAX_GAS, NEAR_ESCROW_MIN_GAS, NEAR_ESCROW_TOKENS, type NearEscrowDelegate, type NearEscrowDelegateOptions, type NearEscrowFunctionCall, type NearEscrowLifecycleMethod, type NearEscrowNetwork, type NearEscrowPayment, type NearLocalSigner, type NearUnsigned, type PaymentIdParams, type WalletSelectorOptions, buildEscrowAuthorizationDelegate, buildEscrowMsg, computePaymentId, createNearLocalSigner, NEARProvider as default, paymentIdPreimage, reclaim, refund, release, signEscrowAuthorization, signEscrowLifecycle, validateEscrowAuthorizationDelegate, withdraw, withdrawFor };

package/dist/providers/near/index.js

@@ -3,6 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var ethers = require('ethers');
+var ed25519 = require('@noble/curves/ed25519');
+var sha256 = require('@noble/hashes/sha256');
 
 // src/types/index.ts
 var CAIP2_IDENTIFIERS = {
@@ -1298,6 +1300,257 @@ function chainToCAIP2(chainName) {
   }
   return chainName;
 }
+var NEAR_ESCROW_MIN_GAS = 38000000000000n;
+var NEAR_ESCROW_MAX_GAS = 100000000000000n;
+var NEAR_ESCROW_TOKENS = Object.freeze({
+  "near:mainnet": "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1",
+  "near:testnet": "3e2210e1184b45b64c8a434c0a7e7b23cc04ea7eb7a6c3c32520d03d4afcb8af"
+});
+var NEAR_ESCROW_CONTRACTS = Object.freeze({
+  "near:testnet": Object.freeze(["arras-v1b-1101.testnet"]),
+  "near:mainnet": Object.freeze([])
+});
+var NONCE_RANGE_MULTIPLIER = 1000000n;
+function fullMatch(pattern, value) {
+  return pattern.exec(value)?.[0] === value;
+}
+function uint(value, bits, name) {
+  if (typeof value !== "bigint" && typeof value !== "number" && typeof value !== "string" || typeof value === "number" && !Number.isSafeInteger(value) || typeof value === "string" && !fullMatch(/^(0|[1-9][0-9]*)$/, value)) {
+    throw new Error(`${name}: expected an exact unsigned integer`);
+  }
+  const n = BigInt(value);
+  if (n < 0n || n >= 1n << BigInt(bits)) throw new Error(`${name}: out of u${bits} range`);
+  return n;
+}
+function account(value, name) {
+  if (typeof value !== "string" || value.length < 2 || value.length > 64 || !fullMatch(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/, value)) throw new Error(`${name}: invalid NEAR account`);
+}
+function hex(value, size, name) {
+  if (typeof value !== "string" || value.length !== size * 2 || !fullMatch(/^[0-9a-f]+$/, value)) {
+    throw new Error(`${name}: expected ${size} bytes of lowercase hex without 0x`);
+  }
+  return Uint8Array.from(value.match(/../g), (v) => parseInt(v, 16));
+}
+function concat(...parts) {
+  const out = new Uint8Array(parts.reduce((sum, p) => sum + p.length, 0));
+  let at = 0;
+  for (const part of parts) {
+    out.set(part, at);
+    at += part.length;
+  }
+  return out;
+}
+function le(n, size) {
+  return Uint8Array.from({ length: size }, (_, i) => Number(n >> BigInt(i * 8) & 255n));
+}
+function str(s) {
+  const bytes = new TextEncoder().encode(s);
+  return concat(le(BigInt(bytes.length), 4), bytes);
+}
+function unbase58(value) {
+  const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  if (!value || value.length > 128) throw new Error("Invalid base58 length");
+  let n = 0n;
+  for (const c of value) {
+    const digit = alphabet.indexOf(c);
+    if (digit < 0) throw new Error("Invalid base58 character");
+    n = n * 58n + BigInt(digit);
+  }
+  const bytes = [];
+  while (n > 0n) {
+    bytes.push(Number(n & 255n));
+    n >>= 8n;
+  }
+  const zeros = value.match(/^1*/u)[0].length;
+  return concat(new Uint8Array(zeros), Uint8Array.from(bytes.reverse()));
+}
+function msgValues(p) {
+  if (typeof p.operator_id !== "string" || !fullMatch(/^[a-z0-9_-]{1,32}$/, p.operator_id)) {
+    throw new Error("operator_id: expected [a-z0-9_-]{1,32}");
+  }
+  account(p.receiver, "receiver");
+  const release2 = uint(p.release_deadline, 64, "release_deadline");
+  const reclaim2 = uint(p.reclaim_after, 64, "reclaim_after");
+  if (release2 >= reclaim2) throw new Error("release_deadline must precede reclaim_after");
+  if (typeof p.fee_bps_max !== "number") throw new Error("fee_bps_max: expected a number");
+  const fee = uint(p.fee_bps_max, 16, "fee_bps_max");
+  return { release: release2, reclaim: reclaim2, fee, terms: hex(p.terms_hash, 32, "terms_hash"), salt: hex(p.salt, 16, "salt") };
+}
+function buildEscrowMsg(p) {
+  const v = msgValues(p);
+  return JSON.stringify({
+    v: 1,
+    action: "authorize",
+    operator_id: p.operator_id,
+    receiver: p.receiver,
+    release_deadline: v.release.toString(),
+    reclaim_after: v.reclaim.toString(),
+    fee_bps_max: Number(v.fee),
+    terms_hash: p.terms_hash,
+    salt: p.salt
+  });
+}
+function paymentIdPreimage(p) {
+  const v = msgValues(p);
+  account(p.token, "token");
+  account(p.payer, "payer");
+  return concat(
+    Uint8Array.of(1),
+    str(p.operator_id),
+    str(p.token),
+    str(p.payer),
+    str(p.receiver),
+    le(uint(p.amount, 128, "amount"), 16),
+    le(v.release, 8),
+    le(v.reclaim, 8),
+    le(v.fee, 2),
+    v.terms,
+    v.salt
+  );
+}
+function computePaymentId(p) {
+  return ethers.encodeBase58(sha256.sha256(paymentIdPreimage(p)));
+}
+function createNearLocalSigner(secret) {
+  let raw;
+  if (typeof secret === "string") {
+    if (!secret.startsWith("ed25519:")) throw new Error("Expected ed25519: secret key");
+    raw = unbase58(secret.slice(8));
+    if (raw.length !== 64) throw new Error("NEAR secret key must contain 64 bytes");
+  } else if (secret instanceof Uint8Array && secret.length === 32) {
+    raw = new Uint8Array(secret);
+  } else throw new Error("Expected a 32-byte seed or NEAR secret key");
+  const seed = raw.slice(0, 32);
+  const publicKey = ed25519.ed25519.getPublicKey(seed);
+  if (raw.length === 64 && !raw.slice(32).every((b, i) => b === publicKey[i])) {
+    throw new Error("NEAR secret key public half does not match seed");
+  }
+  return { get publicKey() {
+    return publicKey.slice();
+  }, sign: (digest) => ed25519.ed25519.sign(digest, seed) };
+}
+function delegateOptions(o) {
+  if (o.network !== "near:mainnet" && o.network !== "near:testnet") throw new Error("Unsupported NEAR network");
+  account(o.senderId, "senderId");
+  account(o.escrowContract, "escrowContract");
+  if (!NEAR_ESCROW_CONTRACTS[o.network].includes(o.escrowContract)) {
+    throw new Error(`escrowContract: not a registered Arras escrow for ${o.network}`);
+  }
+  const nonce = uint(o.nonce, 64, "nonce");
+  if (nonce === 0n) throw new Error("nonce must be positive");
+  const height = uint(o.maxBlockHeight, 64, "maxBlockHeight");
+  if (height === 0n) throw new Error("maxBlockHeight must be positive");
+  if (nonce >= height * NONCE_RANGE_MULTIPLIER) throw new Error("nonce must be below maxBlockHeight * 10^6");
+}
+function buildEscrowAuthorizationDelegate(o) {
+  delegateOptions(o);
+  if (o.token !== NEAR_ESCROW_TOKENS[o.network]) throw new Error("token does not match network USDC");
+  if (o.msg.receiver === o.senderId || o.msg.receiver === o.escrowContract) throw new Error("receiver equals payer or escrow");
+  const amount = uint(o.amount, 128, "amount");
+  if (amount === 0n) throw new Error("amount must be positive");
+  return {
+    senderId: o.senderId,
+    receiverId: o.token,
+    nonce: o.nonce,
+    maxBlockHeight: o.maxBlockHeight,
+    actions: [{ methodName: "ft_transfer_call", args: JSON.stringify({
+      receiver_id: o.escrowContract,
+      amount: amount.toString(),
+      msg: buildEscrowMsg(o.msg)
+    }), gas: o.gas ?? NEAR_ESCROW_MAX_GAS, deposit: 1n }]
+  };
+}
+function validateEscrowAuthorizationDelegate(d, o) {
+  const expected = buildEscrowAuthorizationDelegate(o);
+  if (d.senderId !== expected.senderId || d.receiverId !== expected.receiverId || uint(d.nonce, 64, "nonce") !== uint(expected.nonce, 64, "nonce") || uint(d.maxBlockHeight, 64, "maxBlockHeight") !== uint(expected.maxBlockHeight, 64, "maxBlockHeight")) {
+    throw new Error("Delegate does not match authorization");
+  }
+  if (d.actions.length !== 1) throw new Error("Expected exactly one action");
+  const a = d.actions[0];
+  if (a.methodName !== "ft_transfer_call" || a.args !== expected.actions[0].args) throw new Error("FT method or arguments mismatch");
+  if (uint(a.deposit, 128, "deposit") !== 1n) throw new Error("FT deposit must be 1 yocto");
+  const gas = uint(a.gas, 64, "gas");
+  if (gas < NEAR_ESCROW_MIN_GAS || gas > NEAR_ESCROW_MAX_GAS) throw new Error("FT gas outside 38..100 TGas");
+}
+async function signDelegate(o, d) {
+  const network = o.network;
+  const pk = new Uint8Array(o.signer.publicKey);
+  if (pk.length !== 32) throw new Error("Expected 32-byte Ed25519 public key");
+  const a = d.actions[0];
+  const bytes = concat(
+    str(d.senderId),
+    str(d.receiverId),
+    le(1n, 4),
+    Uint8Array.of(2),
+    str(a.methodName),
+    str(a.args),
+    le(uint(a.gas, 64, "gas"), 8),
+    le(uint(a.deposit, 128, "deposit"), 16),
+    le(uint(d.nonce, 64, "nonce"), 8),
+    le(uint(d.maxBlockHeight, 64, "maxBlockHeight"), 8),
+    Uint8Array.of(0),
+    pk
+  );
+  const digest = sha256.sha256(concat(Uint8Array.of(110, 1, 0, 64), bytes));
+  const signature = await o.signer.sign(digest.slice());
+  if (!(signature instanceof Uint8Array) || signature.length !== 64 || !ed25519.ed25519.verify(signature, digest, pk)) {
+    throw new Error("Invalid Ed25519 delegate signature");
+  }
+  const signed = concat(bytes, Uint8Array.of(0), signature);
+  return {
+    x402Version: 2,
+    scheme: "escrow",
+    network,
+    payload: { signedDelegateAction: btoa(Array.from(signed, (b) => String.fromCharCode(b)).join("")) }
+  };
+}
+async function signEscrowAuthorization(options) {
+  const o = { ...options };
+  const d = buildEscrowAuthorizationDelegate(o);
+  validateEscrowAuthorizationDelegate(d, o);
+  return signDelegate(o, d);
+}
+var lifecycleGas = Object.freeze({
+  release: 30000000000000n,
+  refund: 30000000000000n,
+  reclaim: 30000000000000n,
+  withdraw: 50000000000000n,
+  withdraw_for: 50000000000000n
+});
+async function signEscrowLifecycle(options, method, args = {}) {
+  const o = { ...options };
+  delegateOptions(o);
+  if (!Object.hasOwn(lifecycleGas, method)) throw new Error("Escrow method not allowed");
+  const gas = uint(o.gas ?? lifecycleGas[method], 64, "gas");
+  const minGas = method === "withdraw" || method === "withdraw_for" ? 29000000000000n : 3000000000000n;
+  if (gas < minGas || gas > lifecycleGas[method]) throw new Error("Lifecycle gas outside method limit");
+  const allowed = method === "release" ? ["payment_id", "amount"] : method === "withdraw" ? [] : method === "withdraw_for" ? ["account"] : ["payment_id"];
+  if (Object.keys(args).some((k) => !allowed.includes(k))) throw new Error("Unexpected lifecycle argument");
+  const params = {};
+  if (method === "withdraw_for") {
+    account(args.account, "account");
+    params.account = args.account;
+  } else if (method !== "withdraw") {
+    if (typeof args.payment_id !== "string" || args.payment_id.length < 32 || args.payment_id.length > 44 || unbase58(args.payment_id).length !== 32) throw new Error("Invalid payment_id");
+    params.payment_id = args.payment_id;
+    if (method === "release") {
+      params.amount = args.amount == null ? null : uint(args.amount, 128, "amount").toString();
+      if (params.amount === "0") throw new Error("release amount must be positive");
+    }
+  }
+  return signDelegate(o, {
+    senderId: o.senderId,
+    receiverId: o.escrowContract,
+    nonce: o.nonce,
+    maxBlockHeight: o.maxBlockHeight,
+    actions: [{ methodName: method, args: JSON.stringify(params), gas, deposit: 0n }]
+  });
+}
+var release = (o, paymentId, amount) => signEscrowLifecycle(o, "release", { payment_id: paymentId, amount });
+var refund = (o, paymentId) => signEscrowLifecycle(o, "refund", { payment_id: paymentId });
+var reclaim = (o, paymentId) => signEscrowLifecycle(o, "reclaim", { payment_id: paymentId });
+var withdraw = (o) => signEscrowLifecycle(o, "withdraw");
+var withdrawFor = (o, account2) => signEscrowLifecycle(o, "withdraw_for", { account: account2 });
 
 // src/providers/near/index.ts
 var NEAR_CONFIG = {
@@ -1378,7 +1631,7 @@ function serializeSignedDelegateAction(delegateActionBytes, signatureBytes) {
   ser.writeFixedBytes(signatureBytes);
   return ser.getBytes();
 }
-async function sha256(data) {
+async function sha2562(data) {
   const hashBuffer = await crypto.subtle.digest("SHA-256", data);
   return new Uint8Array(hashBuffer);
 }
@@ -1622,7 +1875,7 @@ var NEARProvider = class {
       const hashInput = new Uint8Array(NEP366_PREFIX.length + delegateActionBytes.length);
       hashInput.set(NEP366_PREFIX, 0);
       hashInput.set(delegateActionBytes, NEP366_PREFIX.length);
-      const delegateHash = await sha256(hashInput);
+      const delegateHash = await sha2562(hashInput);
       const signature = await this.signMessage(delegateHash);
       const signedDelegateActionBytes = serializeSignedDelegateAction(
         delegateActionBytes,
@@ -1764,17 +2017,17 @@ var NEARProvider = class {
   /**
    * Base58 decode (NEAR style)
    */
-  base58Decode(str) {
+  base58Decode(str2) {
     const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
     const ALPHABET_MAP = {};
     for (let i = 0; i < ALPHABET.length; i++) {
       ALPHABET_MAP[ALPHABET[i]] = i;
     }
     let bytes = [0];
-    for (let i = 0; i < str.length; i++) {
-      const value = ALPHABET_MAP[str[i]];
+    for (let i = 0; i < str2.length; i++) {
+      const value = ALPHABET_MAP[str2[i]];
       if (value === void 0) {
-        throw new Error(`Invalid base58 character: ${str[i]}`);
+        throw new Error(`Invalid base58 character: ${str2[i]}`);
       }
       for (let j = 0; j < bytes.length; j++) {
         bytes[j] *= 58;
@@ -1791,7 +2044,7 @@ var NEARProvider = class {
         carry >>= 8;
       }
     }
-    for (let i = 0; i < str.length && str[i] === "1"; i++) {
+    for (let i = 0; i < str2.length && str2[i] === "1"; i++) {
       bytes.push(0);
     }
     return new Uint8Array(bytes.reverse());
@@ -1818,19 +2071,36 @@ var NEARProvider = class {
         carry = carry / 58 | 0;
       }
     }
-    let str = "";
+    let str2 = "";
     for (let i = 0; i < bytes.length && bytes[i] === 0; i++) {
-      str += "1";
+      str2 += "1";
     }
     for (let i = digits.length - 1; i >= 0; i--) {
-      str += ALPHABET[digits[i]];
+      str2 += ALPHABET[digits[i]];
     }
-    return str;
+    return str2;
   }
 };
 var near_default = NEARProvider;
 
 exports.NEARProvider = NEARProvider;
+exports.NEAR_ESCROW_CONTRACTS = NEAR_ESCROW_CONTRACTS;
+exports.NEAR_ESCROW_MAX_GAS = NEAR_ESCROW_MAX_GAS;
+exports.NEAR_ESCROW_MIN_GAS = NEAR_ESCROW_MIN_GAS;
+exports.NEAR_ESCROW_TOKENS = NEAR_ESCROW_TOKENS;
+exports.buildEscrowAuthorizationDelegate = buildEscrowAuthorizationDelegate;
+exports.buildEscrowMsg = buildEscrowMsg;
+exports.computePaymentId = computePaymentId;
+exports.createNearLocalSigner = createNearLocalSigner;
 exports.default = near_default;
+exports.paymentIdPreimage = paymentIdPreimage;
+exports.reclaim = reclaim;
+exports.refund = refund;
+exports.release = release;
+exports.signEscrowAuthorization = signEscrowAuthorization;
+exports.signEscrowLifecycle = signEscrowLifecycle;
+exports.validateEscrowAuthorizationDelegate = validateEscrowAuthorizationDelegate;
+exports.withdraw = withdraw;
+exports.withdrawFor = withdrawFor;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map