@atumlabs/payment-gateway-client 2.1.0 → 3.0.0

package/dist/cli/send-payment.js

@@ -89,7 +89,7 @@ var require_tron_address = __commonJS({
         hexAddress = base58ToHex2(address);
       }
       hexAddress = hexAddress.replace(/^0x/, "");
-      if (hexAddress.startsWith(TVM_MAINNET_PREFIX)) {
+      if (hexAddress.length === 42 && hexAddress.startsWith(TVM_MAINNET_PREFIX)) {
         hexAddress = hexAddress.substring(2);
       }
       if (hexAddress.length !== 40) {
@@ -103,14 +103,62 @@ var require_tron_address = __commonJS({
   }
 });
 
+// ../contracts/tvm/escrow-encoding/typescript/dist/witness-values.js
+var require_witness_values = __commonJS({
+  "../contracts/tvm/escrow-encoding/typescript/dist/witness-values.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.normalizeBytes32 = normalizeBytes32;
+    exports2.normalizeUint256 = normalizeUint256;
+    exports2.maskedChainIdToHex = maskedChainIdToHex;
+    var ethers_1 = require("ethers");
+    var chain_id_1 = require_chain_id();
+    function normalizeBytes32(label, value) {
+      let bytes;
+      try {
+        bytes = (0, ethers_1.getBytes)(value);
+      } catch {
+        throw new Error(`${label} must be 0x-prefixed hex (32 bytes), got ${JSON.stringify(value)}`);
+      }
+      if (bytes.length !== 32) {
+        throw new Error(`${label} must be exactly 32 bytes, got ${bytes.length}`);
+      }
+      return (0, ethers_1.hexlify)(bytes);
+    }
+    function normalizeUint256(label, value) {
+      let n;
+      try {
+        n = BigInt(value);
+      } catch {
+        throw new Error(`${label} must be an integer (bigint or decimal string), got ${JSON.stringify(value)}`);
+      }
+      if (n < 0n) {
+        throw new Error(`${label} must be non-negative (uint256), got ${n.toString()}`);
+      }
+      return n.toString();
+    }
+    function maskedChainIdToHex(chainId) {
+      if (!Number.isSafeInteger(chainId) || chainId < 0) {
+        throw new Error(`chainId must be a non-negative safe integer, got ${chainId}`);
+      }
+      return `0x${(0, chain_id_1.maskChainId)(chainId).toString(16)}`;
+    }
+  }
+});
+
 // ../contracts/tvm/escrow-encoding/typescript/dist/reserve-encoder.js
 var require_reserve_encoder = __commonJS({
   "../contracts/tvm/escrow-encoding/typescript/dist/reserve-encoder.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.RESERVE_WITNESS_TYPES_WITH_QUOTE_SOURCE = void 0;
     exports2.computeReserveDigest = computeReserveDigest;
+    exports2.buildTvmReserveTypedDataWithQuoteSource = buildTvmReserveTypedDataWithQuoteSource;
+    exports2.computeTvmReserveDigestWithQuoteSource = computeTvmReserveDigestWithQuoteSource;
     var ethers_1 = require("ethers");
     var chain_id_1 = require_chain_id();
+    var tron_address_1 = require_tron_address();
+    var witness_values_1 = require_witness_values();
     var RESERVE_WITNESS_TYPES = {
       ReserveWitness: [
         { name: "paymentId", type: "bytes32" },
@@ -129,6 +177,36 @@ var require_reserve_encoder = __commonJS({
         settler: input.settler
       });
     }
+    exports2.RESERVE_WITNESS_TYPES_WITH_QUOTE_SOURCE = {
+      ReserveWitness: [
+        { name: "depositId", type: "bytes32" },
+        { name: "quoteHash", type: "bytes32" },
+        { name: "settler", type: "address" },
+        { name: "sourceAmount", type: "uint256" }
+      ]
+    };
+    function buildTvmReserveTypedDataWithQuoteSource(input) {
+      return {
+        types: exports2.RESERVE_WITNESS_TYPES_WITH_QUOTE_SOURCE,
+        primaryType: "ReserveWitness",
+        domain: {
+          name: "Escrow",
+          version: "3",
+          chainId: (0, witness_values_1.maskedChainIdToHex)(input.chainId),
+          verifyingContract: (0, tron_address_1.normalizeAddress)(input.escrowContract)
+        },
+        message: {
+          depositId: (0, witness_values_1.normalizeBytes32)("depositId", input.depositId),
+          quoteHash: (0, witness_values_1.normalizeBytes32)("quoteHash", input.quoteHash),
+          settler: (0, tron_address_1.normalizeAddress)(input.settler),
+          sourceAmount: (0, witness_values_1.normalizeUint256)("sourceAmount", input.sourceAmount)
+        }
+      };
+    }
+    function computeTvmReserveDigestWithQuoteSource(input) {
+      const prehash = buildTvmReserveTypedDataWithQuoteSource(input);
+      return ethers_1.TypedDataEncoder.hash(prehash.domain, prehash.types, prehash.message);
+    }
   }
 });
 
@@ -155,11 +233,14 @@ var require_deposit_encoder = __commonJS({
   "../contracts/tvm/escrow-encoding/typescript/dist/deposit-encoder.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.MAX_DESTINATION_BYTES = exports2.PERMIT_WITNESS_TYPES_WITH_DESTINATION = void 0;
     exports2.createTvmPermitWitnessTransferFromPrehash = createTvmPermitWitnessTransferFromPrehash2;
     exports2.hashTvmPermitWitnessTransferFrom = hashTvmPermitWitnessTransferFrom2;
+    exports2.createTvmPermitWitnessTransferFromPrehashWithDestination = createTvmPermitWitnessTransferFromPrehashWithDestination;
     var ethers_1 = require("ethers");
     var chain_id_1 = require_chain_id();
     var tron_address_1 = require_tron_address();
+    var witness_values_1 = require_witness_values();
     var PERMIT_WITNESS_TYPES_V2 = {
       PermitWitnessTransferFrom: [
         { name: "permitted", type: "TokenPermissions" },
@@ -205,6 +286,180 @@ var require_deposit_encoder = __commonJS({
     function hashTvmPermitWitnessTransferFrom2(prehash) {
       return ethers_1.TypedDataEncoder.hash(prehash.domain, prehash.types, prehash.message);
     }
+    exports2.PERMIT_WITNESS_TYPES_WITH_DESTINATION = {
+      PermitWitnessTransferFrom: [
+        { name: "permitted", type: "TokenPermissions" },
+        { name: "spender", type: "address" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+        { name: "witness", type: "DepositWitness" }
+      ],
+      TokenPermissions: [
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" }
+      ],
+      DepositWitness: [
+        { name: "depositRequestHash", type: "bytes32" },
+        { name: "destination", type: "string" },
+        { name: "reserver", type: "address" },
+        { name: "releaser", type: "address" }
+      ]
+    };
+    exports2.MAX_DESTINATION_BYTES = 256;
+    function assertDestinationWithinBounds(destination) {
+      if (destination === "") {
+        throw new Error('destination is empty: the escrow reverts DestinationCannotBeEmpty, and because keccak256("") is a valid bytes32 this would otherwise sign a commitment to no destination at all');
+      }
+      const byteLength = (0, ethers_1.toUtf8Bytes)(destination).length;
+      if (byteLength > exports2.MAX_DESTINATION_BYTES) {
+        throw new Error(`destination is ${byteLength} bytes, over the escrow's MAX_DESTINATION_BYTES of ${exports2.MAX_DESTINATION_BYTES}: the contract reverts DestinationTooLong, so this digest could never be redeemed`);
+      }
+    }
+    function createTvmPermitWitnessTransferFromPrehashWithDestination(params) {
+      assertDestinationWithinBounds(params.destination);
+      return {
+        types: exports2.PERMIT_WITNESS_TYPES_WITH_DESTINATION,
+        primaryType: "PermitWitnessTransferFrom",
+        domain: {
+          name: "Permit2",
+          chainId: (0, witness_values_1.maskedChainIdToHex)(params.chainId),
+          verifyingContract: (0, tron_address_1.normalizeAddress)(params.permit2Address)
+        },
+        message: {
+          permitted: {
+            token: (0, tron_address_1.normalizeAddress)(params.tokenAddress),
+            amount: (0, witness_values_1.normalizeUint256)("amount", params.amount)
+          },
+          spender: (0, tron_address_1.normalizeAddress)(params.spenderAddress),
+          nonce: (0, witness_values_1.normalizeUint256)("nonce", params.nonce),
+          deadline: (0, witness_values_1.normalizeUint256)("deadline", params.deadline),
+          witness: {
+            depositRequestHash: (0, witness_values_1.normalizeBytes32)("depositRequestHash", params.depositRequestHash),
+            destination: params.destination,
+            reserver: (0, tron_address_1.normalizeAddress)(params.reserverAddress),
+            releaser: (0, tron_address_1.normalizeAddress)(params.releaserAddress)
+          }
+        }
+      };
+    }
+  }
+});
+
+// ../contracts/tvm/escrow-encoding/typescript/dist/release-encoder.js
+var require_release_encoder = __commonJS({
+  "../contracts/tvm/escrow-encoding/typescript/dist/release-encoder.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.RELEASE_WITNESS_TYPES_WITH_QUOTE_HASH = void 0;
+    exports2.buildTvmReleaseTypedDataWithQuoteHash = buildTvmReleaseTypedDataWithQuoteHash;
+    exports2.computeTvmReleaseDigestWithQuoteHash = computeTvmReleaseDigestWithQuoteHash;
+    var ethers_1 = require("ethers");
+    var tron_address_1 = require_tron_address();
+    var witness_values_1 = require_witness_values();
+    exports2.RELEASE_WITNESS_TYPES_WITH_QUOTE_HASH = {
+      ReleaseWitness: [
+        { name: "depositId", type: "bytes32" },
+        { name: "quoteHash", type: "bytes32" },
+        { name: "depositRequestHash", type: "bytes32" },
+        { name: "destinationHash", type: "bytes32" },
+        { name: "depositor", type: "address" },
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" },
+        { name: "feeAmount", type: "uint256" },
+        { name: "reserver", type: "address" },
+        { name: "releaser", type: "address" },
+        { name: "settler", type: "address" }
+      ]
+    };
+    function buildTvmReleaseTypedDataWithQuoteHash(input) {
+      const w = input.witness;
+      return {
+        types: exports2.RELEASE_WITNESS_TYPES_WITH_QUOTE_HASH,
+        primaryType: "ReleaseWitness",
+        domain: {
+          name: "Escrow",
+          version: "3",
+          chainId: (0, witness_values_1.maskedChainIdToHex)(input.chainId),
+          verifyingContract: (0, tron_address_1.normalizeAddress)(input.escrowContract)
+        },
+        message: {
+          depositId: (0, witness_values_1.normalizeBytes32)("depositId", w.depositId),
+          quoteHash: (0, witness_values_1.normalizeBytes32)("quoteHash", w.quoteHash),
+          depositRequestHash: (0, witness_values_1.normalizeBytes32)("depositRequestHash", w.depositRequestHash),
+          destinationHash: (0, witness_values_1.normalizeBytes32)("destinationHash", w.destinationHash),
+          depositor: (0, tron_address_1.normalizeAddress)(w.depositor),
+          token: (0, tron_address_1.normalizeAddress)(w.token),
+          amount: (0, witness_values_1.normalizeUint256)("amount", w.amount),
+          feeAmount: (0, witness_values_1.normalizeUint256)("feeAmount", w.feeAmount),
+          reserver: (0, tron_address_1.normalizeAddress)(w.reserver),
+          releaser: (0, tron_address_1.normalizeAddress)(w.releaser),
+          settler: (0, tron_address_1.normalizeAddress)(w.settler)
+        }
+      };
+    }
+    function computeTvmReleaseDigestWithQuoteHash(input) {
+      const prehash = buildTvmReleaseTypedDataWithQuoteHash(input);
+      return ethers_1.TypedDataEncoder.hash(prehash.domain, prehash.types, prehash.message);
+    }
+  }
+});
+
+// ../contracts/tvm/escrow-encoding/typescript/dist/refund-encoder.js
+var require_refund_encoder = __commonJS({
+  "../contracts/tvm/escrow-encoding/typescript/dist/refund-encoder.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.REFUND_WITNESS_TYPES_WITH_QUOTE_HASH = void 0;
+    exports2.buildTvmRefundTypedDataWithQuoteHash = buildTvmRefundTypedDataWithQuoteHash;
+    exports2.computeTvmRefundDigestWithQuoteHash = computeTvmRefundDigestWithQuoteHash;
+    var ethers_1 = require("ethers");
+    var tron_address_1 = require_tron_address();
+    var witness_values_1 = require_witness_values();
+    exports2.REFUND_WITNESS_TYPES_WITH_QUOTE_HASH = {
+      RefundWitness: [
+        { name: "depositId", type: "bytes32" },
+        { name: "quoteHash", type: "bytes32" },
+        { name: "depositRequestHash", type: "bytes32" },
+        { name: "destinationHash", type: "bytes32" },
+        { name: "depositor", type: "address" },
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" },
+        { name: "feeAmount", type: "uint256" },
+        { name: "reserver", type: "address" },
+        { name: "releaser", type: "address" },
+        { name: "settler", type: "address" }
+      ]
+    };
+    function buildTvmRefundTypedDataWithQuoteHash(input) {
+      const w = input.witness;
+      return {
+        types: exports2.REFUND_WITNESS_TYPES_WITH_QUOTE_HASH,
+        primaryType: "RefundWitness",
+        domain: {
+          name: "Escrow",
+          version: "3",
+          chainId: (0, witness_values_1.maskedChainIdToHex)(input.chainId),
+          verifyingContract: (0, tron_address_1.normalizeAddress)(input.escrowContract)
+        },
+        message: {
+          depositId: (0, witness_values_1.normalizeBytes32)("depositId", w.depositId),
+          quoteHash: (0, witness_values_1.normalizeBytes32)("quoteHash", w.quoteHash),
+          depositRequestHash: (0, witness_values_1.normalizeBytes32)("depositRequestHash", w.depositRequestHash),
+          destinationHash: (0, witness_values_1.normalizeBytes32)("destinationHash", w.destinationHash),
+          depositor: (0, tron_address_1.normalizeAddress)(w.depositor),
+          token: (0, tron_address_1.normalizeAddress)(w.token),
+          amount: (0, witness_values_1.normalizeUint256)("amount", w.amount),
+          feeAmount: (0, witness_values_1.normalizeUint256)("feeAmount", w.feeAmount),
+          reserver: (0, tron_address_1.normalizeAddress)(w.reserver),
+          releaser: (0, tron_address_1.normalizeAddress)(w.releaser),
+          settler: (0, tron_address_1.normalizeAddress)(w.settler)
+        }
+      };
+    }
+    function computeTvmRefundDigestWithQuoteHash(input) {
+      const prehash = buildTvmRefundTypedDataWithQuoteHash(input);
+      return ethers_1.TypedDataEncoder.hash(prehash.domain, prehash.types, prehash.message);
+    }
   }
 });
 
@@ -213,7 +468,7 @@ var require_dist = __commonJS({
   "../contracts/tvm/escrow-encoding/typescript/dist/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.hashTvmPermitWitnessTransferFrom = exports2.createTvmPermitWitnessTransferFromPrehash = exports2.computePaymentId = exports2.computeReserveDigest = exports2.normalizeAddress = exports2.base58ToHex = exports2.maskChainId = void 0;
+    exports2.MAX_DESTINATION_BYTES = exports2.createTvmPermitWitnessTransferFromPrehashWithDestination = exports2.PERMIT_WITNESS_TYPES_WITH_DESTINATION = exports2.computeTvmRefundDigestWithQuoteHash = exports2.buildTvmRefundTypedDataWithQuoteHash = exports2.REFUND_WITNESS_TYPES_WITH_QUOTE_HASH = exports2.computeTvmReleaseDigestWithQuoteHash = exports2.buildTvmReleaseTypedDataWithQuoteHash = exports2.RELEASE_WITNESS_TYPES_WITH_QUOTE_HASH = exports2.computeTvmReserveDigestWithQuoteSource = exports2.buildTvmReserveTypedDataWithQuoteSource = exports2.RESERVE_WITNESS_TYPES_WITH_QUOTE_SOURCE = exports2.hashTvmPermitWitnessTransferFrom = exports2.createTvmPermitWitnessTransferFromPrehash = exports2.computePaymentId = exports2.computeReserveDigest = exports2.normalizeAddress = exports2.base58ToHex = exports2.maskChainId = void 0;
     var chain_id_1 = require_chain_id();
     Object.defineProperty(exports2, "maskChainId", { enumerable: true, get: function() {
       return chain_id_1.maskChainId;
@@ -240,6 +495,222 @@ var require_dist = __commonJS({
     Object.defineProperty(exports2, "hashTvmPermitWitnessTransferFrom", { enumerable: true, get: function() {
       return deposit_encoder_1.hashTvmPermitWitnessTransferFrom;
     } });
+    var reserve_encoder_2 = require_reserve_encoder();
+    Object.defineProperty(exports2, "RESERVE_WITNESS_TYPES_WITH_QUOTE_SOURCE", { enumerable: true, get: function() {
+      return reserve_encoder_2.RESERVE_WITNESS_TYPES_WITH_QUOTE_SOURCE;
+    } });
+    Object.defineProperty(exports2, "buildTvmReserveTypedDataWithQuoteSource", { enumerable: true, get: function() {
+      return reserve_encoder_2.buildTvmReserveTypedDataWithQuoteSource;
+    } });
+    Object.defineProperty(exports2, "computeTvmReserveDigestWithQuoteSource", { enumerable: true, get: function() {
+      return reserve_encoder_2.computeTvmReserveDigestWithQuoteSource;
+    } });
+    var release_encoder_1 = require_release_encoder();
+    Object.defineProperty(exports2, "RELEASE_WITNESS_TYPES_WITH_QUOTE_HASH", { enumerable: true, get: function() {
+      return release_encoder_1.RELEASE_WITNESS_TYPES_WITH_QUOTE_HASH;
+    } });
+    Object.defineProperty(exports2, "buildTvmReleaseTypedDataWithQuoteHash", { enumerable: true, get: function() {
+      return release_encoder_1.buildTvmReleaseTypedDataWithQuoteHash;
+    } });
+    Object.defineProperty(exports2, "computeTvmReleaseDigestWithQuoteHash", { enumerable: true, get: function() {
+      return release_encoder_1.computeTvmReleaseDigestWithQuoteHash;
+    } });
+    var refund_encoder_1 = require_refund_encoder();
+    Object.defineProperty(exports2, "REFUND_WITNESS_TYPES_WITH_QUOTE_HASH", { enumerable: true, get: function() {
+      return refund_encoder_1.REFUND_WITNESS_TYPES_WITH_QUOTE_HASH;
+    } });
+    Object.defineProperty(exports2, "buildTvmRefundTypedDataWithQuoteHash", { enumerable: true, get: function() {
+      return refund_encoder_1.buildTvmRefundTypedDataWithQuoteHash;
+    } });
+    Object.defineProperty(exports2, "computeTvmRefundDigestWithQuoteHash", { enumerable: true, get: function() {
+      return refund_encoder_1.computeTvmRefundDigestWithQuoteHash;
+    } });
+    var deposit_encoder_2 = require_deposit_encoder();
+    Object.defineProperty(exports2, "PERMIT_WITNESS_TYPES_WITH_DESTINATION", { enumerable: true, get: function() {
+      return deposit_encoder_2.PERMIT_WITNESS_TYPES_WITH_DESTINATION;
+    } });
+    Object.defineProperty(exports2, "createTvmPermitWitnessTransferFromPrehashWithDestination", { enumerable: true, get: function() {
+      return deposit_encoder_2.createTvmPermitWitnessTransferFromPrehashWithDestination;
+    } });
+    Object.defineProperty(exports2, "MAX_DESTINATION_BYTES", { enumerable: true, get: function() {
+      return deposit_encoder_2.MAX_DESTINATION_BYTES;
+    } });
+  }
+});
+
+// ../schemas/declarations/common/chain-address/typescript/dist/index.js
+var require_dist2 = __commonJS({
+  "../schemas/declarations/common/chain-address/typescript/dist/index.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.InvalidAccountError = exports2.REASONS = exports2.NAMESPACE_SOLANA = exports2.NAMESPACE_TRON = exports2.NAMESPACE_EIP155 = void 0;
+    exports2.supportedNamespaces = supportedNamespaces;
+    exports2.parse = parse;
+    exports2.validate = validate;
+    exports2.checkAccount = checkAccount;
+    var bs58_1 = __importDefault(require("bs58"));
+    var ethers_1 = require("ethers");
+    var tvm_escrow_encoding_1 = require_dist();
+    exports2.NAMESPACE_EIP155 = "eip155";
+    exports2.NAMESPACE_TRON = "tron";
+    exports2.NAMESPACE_SOLANA = "solana";
+    exports2.REASONS = [
+      "EMPTY",
+      "SURROUNDING_WHITESPACE",
+      "UNSUPPORTED_NAMESPACE",
+      "UNPARSEABLE",
+      "ZERO"
+    ];
+    var InvalidAccountError2 = class extends Error {
+      reason;
+      network;
+      account;
+      detail;
+      constructor(reason, network, account, detail = "") {
+        super(messageFor(reason, network, detail));
+        this.name = "InvalidAccountError";
+        this.reason = reason;
+        this.network = network;
+        this.account = account;
+        this.detail = detail;
+      }
+    };
+    exports2.InvalidAccountError = InvalidAccountError2;
+    function messageFor(reason, network, detail) {
+      switch (reason) {
+        case "EMPTY":
+          return "account is required and cannot be empty";
+        case "SURROUNDING_WHITESPACE":
+          return "account must not contain leading or trailing whitespace";
+        case "UNSUPPORTED_NAMESPACE":
+          return `no address rules are known for chain ${network}`;
+        case "ZERO":
+          return `account is the zero address on ${network}, which cannot receive a payout`;
+        default:
+          return `account is not a valid address for ${network}`;
+      }
+    }
+    function supportedNamespaces() {
+      return [exports2.NAMESPACE_EIP155, exports2.NAMESPACE_SOLANA, exports2.NAMESPACE_TRON];
+    }
+    function trimSurrounding(value) {
+      return value.replace(/^[\s\u0085]+|[\s\u0085]+$/gu, "");
+    }
+    function parse(network, account) {
+      if (trimSurrounding(account) === "") {
+        throw new InvalidAccountError2("EMPTY", network, account);
+      }
+      if (account !== trimSurrounding(account)) {
+        throw new InvalidAccountError2("SURROUNDING_WHITESPACE", network, account);
+      }
+      const separator = network.indexOf(":");
+      if (separator <= 0) {
+        throw new InvalidAccountError2("UNSUPPORTED_NAMESPACE", network, account);
+      }
+      const namespace = network.slice(0, separator);
+      let bytes;
+      try {
+        switch (namespace) {
+          case exports2.NAMESPACE_EIP155:
+            bytes = parseEvm(account);
+            break;
+          case exports2.NAMESPACE_TRON:
+            bytes = parseTron(account);
+            break;
+          case exports2.NAMESPACE_SOLANA:
+            bytes = parseSolana(account);
+            break;
+          default:
+            throw new InvalidAccountError2("UNSUPPORTED_NAMESPACE", network, account);
+        }
+      } catch (error) {
+        if (error instanceof InvalidAccountError2)
+          throw error;
+        throw new InvalidAccountError2("UNPARSEABLE", network, account, error.message);
+      }
+      return { namespace, bytes };
+    }
+    function validate(network, account) {
+      const parsed = parse(network, account);
+      if (isZero(parsed.bytes)) {
+        throw new InvalidAccountError2("ZERO", network, account);
+      }
+      return parsed;
+    }
+    function checkAccount(network, account) {
+      try {
+        validate(network, account);
+        return null;
+      } catch (error) {
+        if (error instanceof InvalidAccountError2)
+          return error;
+        throw error;
+      }
+    }
+    function isZero(bytes) {
+      return bytes.length > 0 && bytes.every((one) => one === 0);
+    }
+    var HEX_40 = /^(0[xX])?[0-9a-fA-F]{40}$/;
+    function parseEvm(account) {
+      if (!HEX_40.test(account)) {
+        throw new Error("expected 40 hex characters, optionally 0x-prefixed");
+      }
+      const body = account.replace(/^0[xX]/, "");
+      const lower = body.toLowerCase();
+      if (body !== lower && body !== body.toUpperCase()) {
+        if ((0, ethers_1.getAddress)(`0x${lower}`) !== account) {
+          throw new Error("mixed-case address fails its EIP-55 checksum");
+        }
+      }
+      return hexToBytes2(lower);
+    }
+    function parseTron(account) {
+      let hexBody;
+      if (account.startsWith("T") && account.length === 34) {
+        try {
+          hexBody = (0, tvm_escrow_encoding_1.base58ToHex)(account);
+        } catch (error) {
+          throw new Error(`base58 address failed its checksum: ${error.message}`);
+        }
+      } else if (account.toLowerCase().startsWith("0x41") && account.length === 44) {
+        hexBody = account.slice(2);
+      } else if (HEX_40.test(account)) {
+        return parseEvm(account);
+      } else {
+        throw new Error("expected a T-prefixed base58 address or 40 hex characters");
+      }
+      hexBody = hexBody.startsWith("41") ? hexBody.slice(2) : hexBody;
+      if (hexBody.length !== 40) {
+        throw new Error(`expected 40 hex characters after conversion, got ${hexBody.length}`);
+      }
+      return hexToBytes2(hexBody);
+    }
+    function parseSolana(account) {
+      let decoded;
+      try {
+        decoded = bs58_1.default.decode(account);
+      } catch {
+        throw new Error("expected a 32-byte base58 public key");
+      }
+      if (decoded.length !== 32) {
+        throw new Error(`expected a 32-byte base58 public key, got ${decoded.length} bytes`);
+      }
+      return decoded;
+    }
+    var HEX_BODY = /^[0-9a-fA-F]*$/;
+    function hexToBytes2(hex) {
+      if (hex.length % 2 !== 0 || !HEX_BODY.test(hex)) {
+        throw new Error("expected hex characters");
+      }
+      const out = new Uint8Array(hex.length / 2);
+      for (let i = 0; i < out.length; i += 1) {
+        out[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+      }
+      return out;
+    }
   }
 });
 
@@ -251,17 +722,104 @@ var require_types = __commonJS({
   }
 });
 
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/destination.js
+var require_destination = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/destination.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DESTINATION_COMMITMENT_WITNESS_VERSION = exports2.MAX_DESTINATION_BYTES = void 0;
+    exports2.usesDestinationCommitment = usesDestinationCommitment;
+    exports2.deriveDepositRequestHash = deriveDepositRequestHash;
+    exports2.buildEscrowDestination = buildEscrowDestination;
+    var ethers_1 = require("ethers");
+    exports2.MAX_DESTINATION_BYTES = 256;
+    var NAMESPACE_EIP155 = "eip155";
+    exports2.DESTINATION_COMMITMENT_WITNESS_VERSION = 4;
+    function usesDestinationCommitment(depositWitnessVersion) {
+      return depositWitnessVersion === void 0 || depositWitnessVersion >= exports2.DESTINATION_COMMITMENT_WITNESS_VERSION;
+    }
+    function deriveDepositRequestHash(requestId) {
+      if (requestId === "") {
+        throw new Error('sender_auth: cannot derive deposit_request_hash: request_id is empty, and keccak256("") is a perfectly valid non-zero bytes32, so this would silently commit every empty-id deposit to the same hash instead of failing');
+      }
+      return (0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)(requestId));
+    }
+    function buildEscrowDestination(assetIdentifier, account) {
+      if (assetIdentifier === "") {
+        throw new Error("sender_auth: destination asset_identifier is empty");
+      }
+      if (account === "") {
+        throw new Error("sender_auth: destination account is empty");
+      }
+      if (assetIdentifier.includes("@") || account.includes("@")) {
+        throw new Error(`sender_auth: destination asset_identifier (${JSON.stringify(assetIdentifier)}) and account (${JSON.stringify(account)}) must not contain '@': it is the separator between them in the committed destination grammar`);
+      }
+      const namespace = caip2Namespace(assetIdentifier);
+      let asset = assetIdentifier;
+      let acct = account;
+      if (namespace === NAMESPACE_EIP155) {
+        asset = asset.toLowerCase();
+        acct = acct.toLowerCase();
+      }
+      const destination = `${asset}@${acct}`;
+      const byteLength = (0, ethers_1.toUtf8Bytes)(destination).length;
+      if (byteLength > exports2.MAX_DESTINATION_BYTES) {
+        throw new Error(`sender_auth: composed destination is ${byteLength} bytes, over the escrow's MAX_DESTINATION_BYTES of ${exports2.MAX_DESTINATION_BYTES}: the contract reverts DestinationTooLong, so this deposit could never be redeemed`);
+      }
+      return destination;
+    }
+    function caip2Namespace(assetIdentifier) {
+      const slash = assetIdentifier.indexOf("/");
+      const chainPart = slash === -1 ? "" : assetIdentifier.slice(0, slash);
+      const assetPart = slash === -1 ? "" : assetIdentifier.slice(slash + 1);
+      if (slash === -1 || chainPart === "" || assetPart === "") {
+        const looksLegacy = !assetIdentifier.includes("/") && countChar(assetIdentifier, ":") === 2;
+        const hint = looksLegacy ? " (this looks like the deprecated `<chain>:<ref>:<asset>` form; migrate it to `<chain>:<ref>/<asset-namespace>:<asset-reference>`)" : "";
+        throw new Error(`sender_auth: destination asset_identifier ${JSON.stringify(assetIdentifier)} is not CAIP-19: expected <caip2-chain-id>/<asset-namespace>:<asset-reference>${hint}`);
+      }
+      const assetColon = assetPart.indexOf(":");
+      if (assetColon <= 0 || assetColon === assetPart.length - 1) {
+        throw new Error(`sender_auth: destination asset_identifier ${JSON.stringify(assetIdentifier)} has a malformed asset part ${JSON.stringify(assetPart)}: expected <asset-namespace>:<asset-reference>`);
+      }
+      const assetNamespace = assetPart.slice(0, assetColon);
+      if (assetNamespace !== assetNamespace.toLowerCase()) {
+        throw new Error(`sender_auth: destination asset_identifier ${JSON.stringify(assetIdentifier)} has a non-canonical asset namespace ${JSON.stringify(assetNamespace)}: the ratified grammar requires it lowercase (${JSON.stringify(assetNamespace.toLowerCase())}). It is rejected rather than normalised because the destination commitment is over these exact bytes`);
+      }
+      const chainColon = chainPart.indexOf(":");
+      if (chainColon <= 0 || chainColon === chainPart.length - 1) {
+        throw new Error(`sender_auth: destination asset_identifier ${JSON.stringify(assetIdentifier)} has a malformed chain part ${JSON.stringify(chainPart)}: expected <namespace>:<reference>`);
+      }
+      const namespace = chainPart.slice(0, chainColon);
+      if (namespace !== namespace.toLowerCase()) {
+        throw new Error(`sender_auth: destination asset_identifier ${JSON.stringify(assetIdentifier)} has a non-canonical chain namespace ${JSON.stringify(namespace)}: the ratified grammar requires it lowercase (${JSON.stringify(namespace.toLowerCase())}). It is rejected rather than normalised because the destination commitment is over these exact bytes`);
+      }
+      return namespace;
+    }
+    function countChar(s, c) {
+      let n = 0;
+      for (const ch of s) {
+        if (ch === c)
+          n++;
+      }
+      return n;
+    }
+  }
+});
+
 // ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/utils.js
 var require_utils = __commonJS({
   "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/utils.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.SOLANA_REPLAY_SLOTS = exports2.PERMIT_NONCE_DOMAIN = exports2.REPLAY_HORIZON_SECS = void 0;
+    exports2.REQUEST_ID_DOMAIN = exports2.SOLANA_REPLAY_BUCKETS = exports2.SOLANA_REPLAY_SLOTS = exports2.PERMIT_NONCE_DOMAIN = exports2.REPLAY_HORIZON_SECS = void 0;
     exports2.resolvePermitDeadline = resolvePermitDeadline;
     exports2.generatePermitNonce = generatePermitNonce;
     exports2.resolvePermitNonce = resolvePermitNonce;
+    exports2.canonicalDepositor = canonicalDepositor;
     exports2.deterministicPermitNonce = deterministicPermitNonce2;
     exports2.deterministicSolanaNonce = deterministicSolanaNonce2;
+    exports2.deterministicRequestId = deterministicRequestId;
+    exports2.parseSourceAsset = parseSourceAsset;
     exports2.sameAddress = sameAddress;
     exports2.assertKeyMatchesSender = assertKeyMatchesSender2;
     exports2.assertToken = assertToken;
@@ -270,8 +828,11 @@ var require_utils = __commonJS({
     exports2.assertSpender = assertSpender;
     exports2.assertWitnessRoles = assertWitnessRoles;
     exports2.assertRolePairComplete = assertRolePairComplete;
+    exports2.assertDestination = assertDestination;
+    exports2.assertDepositRequestHash = assertDepositRequestHash;
     exports2.nowSec = nowSec;
     var ethers_1 = require("ethers");
+    var destination_js_1 = require_destination();
     exports2.REPLAY_HORIZON_SECS = 128;
     function resolvePermitDeadline(deadline) {
       return BigInt(deadline);
@@ -286,7 +847,7 @@ var require_utils = __commonJS({
     }
     exports2.PERMIT_NONCE_DOMAIN = "atum-permit:v1:";
     exports2.SOLANA_REPLAY_SLOTS = 235n;
-    var SOLANA_BUCKET_BITS = 17n;
+    exports2.SOLANA_REPLAY_BUCKETS = 256n;
     function canonicalDepositor(depositor) {
       const lower = depositor.toLowerCase();
       return lower.startsWith("0x") ? lower : depositor;
@@ -303,9 +864,34 @@ var require_utils = __commonJS({
     function deterministicSolanaNonce2(params) {
       const seed = permitNonceSeed(params.requestId, params.depositor);
       const slot = seed % exports2.SOLANA_REPLAY_SLOTS;
-      const bucket = (seed >> 8n) % (1n << SOLANA_BUCKET_BITS);
+      const bucket = (seed >> 8n) % exports2.SOLANA_REPLAY_BUCKETS;
       return bucket << 32n | slot;
     }
+    exports2.REQUEST_ID_DOMAIN = "atum-request:v1:";
+    function deterministicRequestId(params) {
+      if (!params.anchor) {
+        throw new Error("sender_auth: a per-intent anchor is required to derive a deterministic request_id (a random one would silently break idempotency and let a retry double-charge)");
+      }
+      if (!params.account) {
+        throw new Error("sender_auth: account is required to derive a deterministic request_id");
+      }
+      if (!/^[A-Za-z0-9_-]*$/.test(params.prefix)) {
+        throw new Error(`sender_auth: request_id prefix must contain only letters, digits, '_' or '-' (got ${JSON.stringify(params.prefix)})`);
+      }
+      const digest = (0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)(`${exports2.REQUEST_ID_DOMAIN}${params.anchor}:${canonicalDepositor(params.account)}`));
+      return `${params.prefix}${digest.slice(2, 26)}`;
+    }
+    function parseSourceAsset(assetIdentifier) {
+      const parts = typeof assetIdentifier === "string" ? assetIdentifier.split("/") : [];
+      const nsParts = parts[1]?.split(":");
+      if (parts.length === 3 && parts[0] && parts[1] && parts[2]) {
+        throw new Error(`sender_auth: source asset ${JSON.stringify(assetIdentifier)} names a token id, which a deposit cannot bind`);
+      }
+      if (parts.length !== 2 || !parts[0] || !nsParts || nsParts.length !== 2 || !nsParts[0] || !nsParts[1]) {
+        throw new Error(`sender_auth: invalid source asset ${JSON.stringify(assetIdentifier)}`);
+      }
+      return { network: parts[0], asset: nsParts[1] };
+    }
     function sameAddress(a, b) {
       if (a.startsWith("0x") && b.startsWith("0x")) {
         return a.toLowerCase() === b.toLowerCase();
@@ -347,6 +933,17 @@ var require_utils = __commonJS({
         throw new Error("sender_auth: reserver and releaser must be supplied together");
       }
     }
+    function assertDestination(signed, expected) {
+      if (signed !== expected) {
+        throw new Error(`sender_auth: signed deposit destination ${JSON.stringify(signed)} does not match the expected destination ${JSON.stringify(expected)} \u2014 the escrow stores only keccak256(bytes(destination)) and cannot tell a formatting disagreement from a wrong payee, so a deposit signed against this destination could be neither released nor refunded`);
+      }
+    }
+    function assertDepositRequestHash(signedHex, expectedRequestId) {
+      const expected = (0, destination_js_1.deriveDepositRequestHash)(expectedRequestId);
+      if (signedHex.toLowerCase() !== expected.toLowerCase()) {
+        throw new Error(`sender_auth: signed deposit_request_hash ${signedHex} is not keccak256(request_id) for request_id ${JSON.stringify(expectedRequestId)} (expected ${expected}): the deposit authorizes a different payment request`);
+      }
+    }
     function nowSec() {
       return Math.floor(Date.now() / 1e3);
     }
@@ -358,7 +955,7 @@ var require_chain_id2 = __commonJS({
   "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/chain-id.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.TRON_PERMIT2_FALLBACKS = exports2.TRON_CHAIN_IDS = void 0;
+    exports2.TRON_PERMIT2_FALLBACKS = exports2.TRON_CHAIN_IDS = exports2.MAX_EVM_CHAIN_ID = void 0;
     exports2.namespaceOf = namespaceOf;
     exports2.evmChainId = evmChainId;
     exports2.tronNumericChainId = tronNumericChainId;
@@ -367,21 +964,30 @@ var require_chain_id2 = __commonJS({
     function namespaceOf(network) {
       return network.split(":")[0];
     }
+    exports2.MAX_EVM_CHAIN_ID = Number.MAX_SAFE_INTEGER;
     function evmChainId(network) {
       const match = /^eip155:([0-9]+)$/.exec(network);
       if (!match) {
         throw new Error(`sender_auth: expected an eip155 network, got ${network}`);
       }
-      return Number(match[1]);
+      const chainId = Number(match[1]);
+      if (chainId > exports2.MAX_EVM_CHAIN_ID) {
+        throw new Error(`sender_auth: eip155 chain id ${match[1]} exceeds the EIP-2294 maximum (${exports2.MAX_EVM_CHAIN_ID})`);
+      }
+      return chainId;
     }
     exports2.TRON_CHAIN_IDS = {
       mainnet: 728126428,
       shasta: 2494104990
     };
     function tronNumericChainId(network) {
-      const cluster = network.split(":")[1];
-      const id = exports2.TRON_CHAIN_IDS[cluster ?? ""];
-      if (id === void 0) {
+      if (namespaceOf(network) !== "tron") {
+        throw new Error(`sender_auth: expected a tron network, got ${network}`);
+      }
+      const segments = network.split(":");
+      const cluster = segments.length === 2 ? segments[1] : void 0;
+      const id = cluster !== void 0 && Object.hasOwn(exports2.TRON_CHAIN_IDS, cluster) ? exports2.TRON_CHAIN_IDS[cluster] : void 0;
+      if (typeof id !== "number") {
         throw new Error(`sender_auth: unsupported Tron network '${network}'`);
       }
       return id;
@@ -391,8 +997,8 @@ var require_chain_id2 = __commonJS({
       "tron:shasta": "TPUqJPASUn1zLvbLBgRZ5pBYrx7WSe5ahp"
     };
     function resolveTronPermit2(network) {
-      const resolved = exports2.TRON_PERMIT2_FALLBACKS[network];
-      if (!resolved) {
+      const resolved = Object.hasOwn(exports2.TRON_PERMIT2_FALLBACKS, network) ? exports2.TRON_PERMIT2_FALLBACKS[network] : void 0;
+      if (typeof resolved !== "string" || resolved === "") {
         throw new Error(`sender_auth: no Permit2 address known for Tron network '${network}'`);
       }
       return resolved;
@@ -448,7 +1054,7 @@ var require_permit_types = __commonJS({
   "../contracts/evm/escrow-encoding/typescript/dist/permit-types.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.REFUND_WITNESS_TYPES = exports2.RELEASE_WITNESS_TYPES = exports2.RESERVE_WITNESS_TYPES = exports2.PERMIT_WITNESS_TYPES_V2 = exports2.PERMIT_WITNESS_TYPES = void 0;
+    exports2.REFUND_WITNESS_TYPES_WITH_QUOTE_HASH = exports2.RELEASE_WITNESS_TYPES_WITH_QUOTE_HASH = exports2.RESERVE_WITNESS_TYPES_WITH_QUOTE_SOURCE = exports2.PERMIT_WITNESS_TYPES_WITH_DESTINATION = exports2.REFUND_WITNESS_TYPES = exports2.RELEASE_WITNESS_TYPES = exports2.RESERVE_WITNESS_TYPES = exports2.PERMIT_WITNESS_TYPES_V2 = exports2.PERMIT_WITNESS_TYPES = void 0;
     exports2.createPermit2Domain = createPermit2Domain;
     exports2.createEscrowDomain = createEscrowDomain;
     exports2.PERMIT_WITNESS_TYPES = {
@@ -531,36 +1137,93 @@ var require_permit_types = __commonJS({
         { name: "settler", type: "address" }
       ]
     };
-  }
-});
-
-// ../contracts/evm/escrow-encoding/typescript/dist/escrow-abi.js
-var require_escrow_abi = __commonJS({
-  "../contracts/evm/escrow-encoding/typescript/dist/escrow-abi.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ESCROW_V2_ABI_JSON = exports2.ESCROW_V3_ABI_JSON = exports2.ESCROW_ABI_JSON = exports2.ESCROW_ABI = void 0;
-    exports2.ESCROW_ABI = [
-      "function deposit((( address token, uint256 amount) permitted, uint256 nonce, uint256 deadline) permit, address depositor, (bytes32 requestId, address reserver, address releaser) witness, bytes signature) returns (bytes32)",
-      "function refund((bytes32 depositId, uint256 deadline) witness, bytes signature)",
-      "function getDepositInfo(bytes32 depositId) view returns ((address depositor, address token, uint256 amount, address reserver, address releaser, address settler))",
-      "function i_permit2() view returns (address)"
-    ];
-    exports2.ESCROW_ABI_JSON = [
-      {
-        type: "function",
-        name: "deposit",
-        inputs: [
-          {
-            name: "permit",
-            type: "tuple",
-            components: [
-              {
-                name: "permitted",
-                type: "tuple",
-                components: [
-                  { name: "token", type: "address" },
-                  { name: "amount", type: "uint256" }
+    exports2.PERMIT_WITNESS_TYPES_WITH_DESTINATION = {
+      PermitWitnessTransferFrom: [
+        { name: "permitted", type: "TokenPermissions" },
+        { name: "spender", type: "address" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" },
+        { name: "witness", type: "DepositWitness" }
+      ],
+      TokenPermissions: [
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" }
+      ],
+      DepositWitness: [
+        { name: "depositRequestHash", type: "bytes32" },
+        { name: "destination", type: "string" },
+        { name: "reserver", type: "address" },
+        { name: "releaser", type: "address" }
+      ]
+    };
+    exports2.RESERVE_WITNESS_TYPES_WITH_QUOTE_SOURCE = {
+      ReserveWitness: [
+        { name: "depositId", type: "bytes32" },
+        { name: "quoteHash", type: "bytes32" },
+        { name: "settler", type: "address" },
+        { name: "sourceAmount", type: "uint256" }
+      ]
+    };
+    exports2.RELEASE_WITNESS_TYPES_WITH_QUOTE_HASH = {
+      ReleaseWitness: [
+        { name: "depositId", type: "bytes32" },
+        { name: "quoteHash", type: "bytes32" },
+        { name: "depositRequestHash", type: "bytes32" },
+        { name: "destinationHash", type: "bytes32" },
+        { name: "depositor", type: "address" },
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" },
+        { name: "feeAmount", type: "uint256" },
+        { name: "reserver", type: "address" },
+        { name: "releaser", type: "address" },
+        { name: "settler", type: "address" }
+      ]
+    };
+    exports2.REFUND_WITNESS_TYPES_WITH_QUOTE_HASH = {
+      RefundWitness: [
+        { name: "depositId", type: "bytes32" },
+        { name: "quoteHash", type: "bytes32" },
+        { name: "depositRequestHash", type: "bytes32" },
+        { name: "destinationHash", type: "bytes32" },
+        { name: "depositor", type: "address" },
+        { name: "token", type: "address" },
+        { name: "amount", type: "uint256" },
+        { name: "feeAmount", type: "uint256" },
+        { name: "reserver", type: "address" },
+        { name: "releaser", type: "address" },
+        { name: "settler", type: "address" }
+      ]
+    };
+  }
+});
+
+// ../contracts/evm/escrow-encoding/typescript/dist/escrow-abi.js
+var require_escrow_abi = __commonJS({
+  "../contracts/evm/escrow-encoding/typescript/dist/escrow-abi.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ESCROW_V2_ABI_JSON = exports2.ESCROW_V3_ABI_JSON = exports2.ESCROW_ABI_JSON = exports2.ESCROW_ABI = void 0;
+    exports2.ESCROW_ABI = [
+      "function deposit((( address token, uint256 amount) permitted, uint256 nonce, uint256 deadline) permit, address depositor, (bytes32 requestId, address reserver, address releaser) witness, bytes signature) returns (bytes32)",
+      "function refund((bytes32 depositId, uint256 deadline) witness, bytes signature)",
+      "function getDepositInfo(bytes32 depositId) view returns ((address depositor, address token, uint256 amount, address reserver, address releaser, address settler))",
+      "function i_permit2() view returns (address)"
+    ];
+    exports2.ESCROW_ABI_JSON = [
+      {
+        type: "function",
+        name: "deposit",
+        inputs: [
+          {
+            name: "permit",
+            type: "tuple",
+            components: [
+              {
+                name: "permitted",
+                type: "tuple",
+                components: [
+                  { name: "token", type: "address" },
+                  { name: "amount", type: "uint256" }
                 ]
               },
               { name: "nonce", type: "uint256" },
@@ -657,6 +1320,8 @@ var require_escrow_abi = __commonJS({
                 name: "depositWitness",
                 type: "tuple",
                 components: [
+                  { name: "depositRequestHash", type: "bytes32" },
+                  { name: "destination", type: "string" },
                   { name: "reserver", type: "address" },
                   { name: "releaser", type: "address" }
                 ]
@@ -666,15 +1331,17 @@ var require_escrow_abi = __commonJS({
                 name: "reserveWitness",
                 type: "tuple",
                 components: [
-                  { name: "paymentId", type: "bytes32" },
-                  { name: "settler", type: "address" }
+                  { name: "depositId", type: "bytes32" },
+                  { name: "quoteHash", type: "bytes32" },
+                  { name: "settler", type: "address" },
+                  { name: "sourceAmount", type: "uint256" }
                 ]
               },
               { name: "reserveSignature", type: "bytes" }
             ]
           }
         ],
-        outputs: [{ name: "paymentId", type: "bytes32" }],
+        outputs: [{ name: "depositId", type: "bytes32" }],
         stateMutability: "nonpayable"
       },
       {
@@ -689,7 +1356,10 @@ var require_escrow_abi = __commonJS({
                 name: "refundWitness",
                 type: "tuple",
                 components: [
-                  { name: "paymentId", type: "bytes32" },
+                  { name: "depositId", type: "bytes32" },
+                  { name: "quoteHash", type: "bytes32" },
+                  { name: "depositRequestHash", type: "bytes32" },
+                  { name: "destinationHash", type: "bytes32" },
                   { name: "depositor", type: "address" },
                   { name: "token", type: "address" },
                   { name: "amount", type: "uint256" },
@@ -709,7 +1379,7 @@ var require_escrow_abi = __commonJS({
       {
         type: "function",
         name: "getDepositHash",
-        inputs: [{ name: "paymentId", type: "bytes32" }],
+        inputs: [{ name: "depositId", type: "bytes32" }],
         outputs: [{ name: "", type: "bytes32" }],
         stateMutability: "view"
       },
@@ -725,14 +1395,67 @@ var require_escrow_abi = __commonJS({
   }
 });
 
+// ../contracts/evm/escrow-encoding/typescript/dist/witness-values.js
+var require_witness_values2 = __commonJS({
+  "../contracts/evm/escrow-encoding/typescript/dist/witness-values.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.normalizeBytes32 = normalizeBytes32;
+    exports2.normalizeAddressField = normalizeAddressField;
+    exports2.normalizeUint256 = normalizeUint256;
+    exports2.chainIdToHex = chainIdToHex;
+    var ethers_1 = require("ethers");
+    function normalizeBytes32(label, value) {
+      let bytes;
+      try {
+        bytes = (0, ethers_1.getBytes)(value);
+      } catch {
+        throw new Error(`${label} must be 0x-prefixed hex (32 bytes), got ${JSON.stringify(value)}`);
+      }
+      if (bytes.length !== 32) {
+        throw new Error(`${label} must be exactly 32 bytes, got ${bytes.length}`);
+      }
+      return (0, ethers_1.hexlify)(bytes);
+    }
+    function normalizeAddressField(label, value) {
+      try {
+        return (0, ethers_1.getAddress)(value);
+      } catch {
+        throw new Error(`${label} must be a 20-byte hex address, got ${JSON.stringify(value)}`);
+      }
+    }
+    function normalizeUint256(label, value) {
+      let n;
+      try {
+        n = BigInt(value);
+      } catch {
+        throw new Error(`${label} must be an integer (bigint or decimal string), got ${JSON.stringify(value)}`);
+      }
+      if (n < 0n) {
+        throw new Error(`${label} must be non-negative (uint256), got ${n.toString()}`);
+      }
+      return n.toString();
+    }
+    function chainIdToHex(chainId) {
+      if (!Number.isSafeInteger(chainId) || chainId < 0) {
+        throw new Error(`chainId must be a non-negative safe integer, got ${chainId}`);
+      }
+      return `0x${chainId.toString(16)}`;
+    }
+  }
+});
+
 // ../contracts/evm/escrow-encoding/typescript/dist/reserve-encoder.js
 var require_reserve_encoder2 = __commonJS({
   "../contracts/evm/escrow-encoding/typescript/dist/reserve-encoder.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.computeReserveDigest = computeReserveDigest;
+    exports2.buildReserveTypedDataWithQuoteSource = buildReserveTypedDataWithQuoteSource;
+    exports2.computeReserveDigestWithQuoteSource = computeReserveDigestWithQuoteSource;
     var ethers_1 = require("ethers");
     var permit_types_1 = require_permit_types();
+    var witness_values_1 = require_witness_values2();
     function computeReserveDigest(input) {
       const domain = (0, permit_types_1.createEscrowDomain)(input.chainId, input.escrowContract);
       return ethers_1.TypedDataEncoder.hash(domain, permit_types_1.RESERVE_WITNESS_TYPES, {
@@ -740,6 +1463,114 @@ var require_reserve_encoder2 = __commonJS({
         settler: input.settler
       });
     }
+    function buildReserveTypedDataWithQuoteSource(input) {
+      return {
+        types: permit_types_1.RESERVE_WITNESS_TYPES_WITH_QUOTE_SOURCE,
+        primaryType: "ReserveWitness",
+        domain: {
+          name: "Escrow",
+          version: "3",
+          chainId: (0, witness_values_1.chainIdToHex)(input.chainId),
+          verifyingContract: (0, witness_values_1.normalizeAddressField)("escrowContract", input.escrowContract)
+        },
+        message: {
+          depositId: (0, witness_values_1.normalizeBytes32)("depositId", input.depositId),
+          quoteHash: (0, witness_values_1.normalizeBytes32)("quoteHash", input.quoteHash),
+          settler: (0, witness_values_1.normalizeAddressField)("settler", input.settler),
+          sourceAmount: (0, witness_values_1.normalizeUint256)("sourceAmount", input.sourceAmount)
+        }
+      };
+    }
+    function computeReserveDigestWithQuoteSource(input) {
+      const prehash = buildReserveTypedDataWithQuoteSource(input);
+      return ethers_1.TypedDataEncoder.hash(prehash.domain, prehash.types, prehash.message);
+    }
+  }
+});
+
+// ../contracts/evm/escrow-encoding/typescript/dist/release-encoder.js
+var require_release_encoder2 = __commonJS({
+  "../contracts/evm/escrow-encoding/typescript/dist/release-encoder.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.buildReleaseTypedDataWithQuoteHash = buildReleaseTypedDataWithQuoteHash;
+    exports2.computeReleaseDigestWithQuoteHash = computeReleaseDigestWithQuoteHash;
+    var ethers_1 = require("ethers");
+    var permit_types_1 = require_permit_types();
+    var witness_values_1 = require_witness_values2();
+    function buildReleaseTypedDataWithQuoteHash(input) {
+      const w = input.witness;
+      return {
+        types: permit_types_1.RELEASE_WITNESS_TYPES_WITH_QUOTE_HASH,
+        primaryType: "ReleaseWitness",
+        domain: {
+          name: "Escrow",
+          version: "3",
+          chainId: (0, witness_values_1.chainIdToHex)(input.chainId),
+          verifyingContract: (0, witness_values_1.normalizeAddressField)("escrowContract", input.escrowContract)
+        },
+        message: {
+          depositId: (0, witness_values_1.normalizeBytes32)("depositId", w.depositId),
+          quoteHash: (0, witness_values_1.normalizeBytes32)("quoteHash", w.quoteHash),
+          depositRequestHash: (0, witness_values_1.normalizeBytes32)("depositRequestHash", w.depositRequestHash),
+          destinationHash: (0, witness_values_1.normalizeBytes32)("destinationHash", w.destinationHash),
+          depositor: (0, witness_values_1.normalizeAddressField)("depositor", w.depositor),
+          token: (0, witness_values_1.normalizeAddressField)("token", w.token),
+          amount: (0, witness_values_1.normalizeUint256)("amount", w.amount),
+          feeAmount: (0, witness_values_1.normalizeUint256)("feeAmount", w.feeAmount),
+          reserver: (0, witness_values_1.normalizeAddressField)("reserver", w.reserver),
+          releaser: (0, witness_values_1.normalizeAddressField)("releaser", w.releaser),
+          settler: (0, witness_values_1.normalizeAddressField)("settler", w.settler)
+        }
+      };
+    }
+    function computeReleaseDigestWithQuoteHash(input) {
+      const prehash = buildReleaseTypedDataWithQuoteHash(input);
+      return ethers_1.TypedDataEncoder.hash(prehash.domain, prehash.types, prehash.message);
+    }
+  }
+});
+
+// ../contracts/evm/escrow-encoding/typescript/dist/refund-encoder.js
+var require_refund_encoder2 = __commonJS({
+  "../contracts/evm/escrow-encoding/typescript/dist/refund-encoder.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.buildRefundTypedDataWithQuoteHash = buildRefundTypedDataWithQuoteHash;
+    exports2.computeRefundDigestWithQuoteHash = computeRefundDigestWithQuoteHash;
+    var ethers_1 = require("ethers");
+    var permit_types_1 = require_permit_types();
+    var witness_values_1 = require_witness_values2();
+    function buildRefundTypedDataWithQuoteHash(input) {
+      const w = input.witness;
+      return {
+        types: permit_types_1.REFUND_WITNESS_TYPES_WITH_QUOTE_HASH,
+        primaryType: "RefundWitness",
+        domain: {
+          name: "Escrow",
+          version: "3",
+          chainId: (0, witness_values_1.chainIdToHex)(input.chainId),
+          verifyingContract: (0, witness_values_1.normalizeAddressField)("escrowContract", input.escrowContract)
+        },
+        message: {
+          depositId: (0, witness_values_1.normalizeBytes32)("depositId", w.depositId),
+          quoteHash: (0, witness_values_1.normalizeBytes32)("quoteHash", w.quoteHash),
+          depositRequestHash: (0, witness_values_1.normalizeBytes32)("depositRequestHash", w.depositRequestHash),
+          destinationHash: (0, witness_values_1.normalizeBytes32)("destinationHash", w.destinationHash),
+          depositor: (0, witness_values_1.normalizeAddressField)("depositor", w.depositor),
+          token: (0, witness_values_1.normalizeAddressField)("token", w.token),
+          amount: (0, witness_values_1.normalizeUint256)("amount", w.amount),
+          feeAmount: (0, witness_values_1.normalizeUint256)("feeAmount", w.feeAmount),
+          reserver: (0, witness_values_1.normalizeAddressField)("reserver", w.reserver),
+          releaser: (0, witness_values_1.normalizeAddressField)("releaser", w.releaser),
+          settler: (0, witness_values_1.normalizeAddressField)("settler", w.settler)
+        }
+      };
+    }
+    function computeRefundDigestWithQuoteHash(input) {
+      const prehash = buildRefundTypedDataWithQuoteHash(input);
+      return ethers_1.TypedDataEncoder.hash(prehash.domain, prehash.types, prehash.message);
+    }
   }
 });
 
@@ -748,11 +1579,13 @@ var require_deposit_encoder2 = __commonJS({
   "../contracts/evm/escrow-encoding/typescript/dist/deposit-encoder.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.PERMIT2_CONTRACT_ADDRESS = void 0;
+    exports2.MAX_DESTINATION_BYTES = exports2.PERMIT2_CONTRACT_ADDRESS = void 0;
     exports2.createPermitWitnessTransferFromPrehash = createPermitWitnessTransferFromPrehash2;
     exports2.hashPermitWitnessTransferFrom = hashPermitWitnessTransferFrom2;
+    exports2.createPermitWitnessTransferFromPrehashWithDestination = createPermitWitnessTransferFromPrehashWithDestination;
     var ethers_1 = require("ethers");
     var permit_types_1 = require_permit_types();
+    var witness_values_1 = require_witness_values2();
     exports2.PERMIT2_CONTRACT_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
     function createPermitWitnessTransferFromPrehash2(params) {
       return {
@@ -781,15 +1614,52 @@ var require_deposit_encoder2 = __commonJS({
     function hashPermitWitnessTransferFrom2(prehash) {
       return ethers_1.TypedDataEncoder.hash(prehash.domain, prehash.types, prehash.message);
     }
+    exports2.MAX_DESTINATION_BYTES = 256;
+    function assertDestinationWithinBounds(destination) {
+      if (destination === "") {
+        throw new Error('destination is empty: the escrow reverts DestinationCannotBeEmpty, and because keccak256("") is a valid bytes32 this would otherwise sign a commitment to no destination at all');
+      }
+      const byteLength = (0, ethers_1.toUtf8Bytes)(destination).length;
+      if (byteLength > exports2.MAX_DESTINATION_BYTES) {
+        throw new Error(`destination is ${byteLength} bytes, over the escrow's MAX_DESTINATION_BYTES of ${exports2.MAX_DESTINATION_BYTES}: the contract reverts DestinationTooLong, so this digest could never be redeemed`);
+      }
+    }
+    function createPermitWitnessTransferFromPrehashWithDestination(params) {
+      assertDestinationWithinBounds(params.destination);
+      return {
+        types: permit_types_1.PERMIT_WITNESS_TYPES_WITH_DESTINATION,
+        primaryType: "PermitWitnessTransferFrom",
+        domain: {
+          name: "Permit2",
+          chainId: (0, witness_values_1.chainIdToHex)(params.chainId),
+          verifyingContract: (0, witness_values_1.normalizeAddressField)("verifyingContract", params.verifyingContract)
+        },
+        message: {
+          permitted: {
+            token: (0, witness_values_1.normalizeAddressField)("token", params.token),
+            amount: (0, witness_values_1.normalizeUint256)("amount", params.amount)
+          },
+          spender: (0, witness_values_1.normalizeAddressField)("spender", params.spender),
+          nonce: (0, witness_values_1.normalizeUint256)("nonce", params.nonce),
+          deadline: (0, witness_values_1.normalizeUint256)("deadline", params.deadline),
+          witness: {
+            depositRequestHash: (0, witness_values_1.normalizeBytes32)("depositRequestHash", params.depositRequestHash),
+            destination: params.destination,
+            reserver: (0, witness_values_1.normalizeAddressField)("reserver", params.reserver),
+            releaser: (0, witness_values_1.normalizeAddressField)("releaser", params.releaser)
+          }
+        }
+      };
+    }
   }
 });
 
 // ../contracts/evm/escrow-encoding/typescript/dist/index.js
-var require_dist2 = __commonJS({
+var require_dist3 = __commonJS({
   "../contracts/evm/escrow-encoding/typescript/dist/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.PERMIT2_CONTRACT_ADDRESS = exports2.hashPermitWitnessTransferFrom = exports2.createPermitWitnessTransferFromPrehash = exports2.computeReserveDigest = exports2.ESCROW_V3_ABI_JSON = exports2.ESCROW_V2_ABI_JSON = exports2.ESCROW_ABI_JSON = exports2.ESCROW_ABI = exports2.REFUND_WITNESS_TYPES = exports2.RELEASE_WITNESS_TYPES = exports2.RESERVE_WITNESS_TYPES = exports2.createEscrowDomain = exports2.createPermit2Domain = exports2.PERMIT_WITNESS_TYPES_V2 = exports2.PERMIT_WITNESS_TYPES = exports2.generateNonce = exports2.computePaymentIdV2 = exports2.computePaymentId = void 0;
+    exports2.MAX_DESTINATION_BYTES = exports2.createPermitWitnessTransferFromPrehashWithDestination = exports2.PERMIT2_CONTRACT_ADDRESS = exports2.hashPermitWitnessTransferFrom = exports2.createPermitWitnessTransferFromPrehash = exports2.computeRefundDigestWithQuoteHash = exports2.buildRefundTypedDataWithQuoteHash = exports2.computeReleaseDigestWithQuoteHash = exports2.buildReleaseTypedDataWithQuoteHash = exports2.computeReserveDigestWithQuoteSource = exports2.buildReserveTypedDataWithQuoteSource = exports2.computeReserveDigest = exports2.ESCROW_V3_ABI_JSON = exports2.ESCROW_V2_ABI_JSON = exports2.ESCROW_ABI_JSON = exports2.ESCROW_ABI = exports2.REFUND_WITNESS_TYPES_WITH_QUOTE_HASH = exports2.RELEASE_WITNESS_TYPES_WITH_QUOTE_HASH = exports2.RESERVE_WITNESS_TYPES_WITH_QUOTE_SOURCE = exports2.PERMIT_WITNESS_TYPES_WITH_DESTINATION = exports2.REFUND_WITNESS_TYPES = exports2.RELEASE_WITNESS_TYPES = exports2.RESERVE_WITNESS_TYPES = exports2.createEscrowDomain = exports2.createPermit2Domain = exports2.PERMIT_WITNESS_TYPES_V2 = exports2.PERMIT_WITNESS_TYPES = exports2.generateNonce = exports2.computePaymentIdV2 = exports2.computePaymentId = void 0;
     var payment_id_1 = require_payment_id2();
     Object.defineProperty(exports2, "computePaymentId", { enumerable: true, get: function() {
       return payment_id_1.computePaymentId;
@@ -823,6 +1693,19 @@ var require_dist2 = __commonJS({
     Object.defineProperty(exports2, "REFUND_WITNESS_TYPES", { enumerable: true, get: function() {
       return permit_types_1.REFUND_WITNESS_TYPES;
     } });
+    var permit_types_2 = require_permit_types();
+    Object.defineProperty(exports2, "PERMIT_WITNESS_TYPES_WITH_DESTINATION", { enumerable: true, get: function() {
+      return permit_types_2.PERMIT_WITNESS_TYPES_WITH_DESTINATION;
+    } });
+    Object.defineProperty(exports2, "RESERVE_WITNESS_TYPES_WITH_QUOTE_SOURCE", { enumerable: true, get: function() {
+      return permit_types_2.RESERVE_WITNESS_TYPES_WITH_QUOTE_SOURCE;
+    } });
+    Object.defineProperty(exports2, "RELEASE_WITNESS_TYPES_WITH_QUOTE_HASH", { enumerable: true, get: function() {
+      return permit_types_2.RELEASE_WITNESS_TYPES_WITH_QUOTE_HASH;
+    } });
+    Object.defineProperty(exports2, "REFUND_WITNESS_TYPES_WITH_QUOTE_HASH", { enumerable: true, get: function() {
+      return permit_types_2.REFUND_WITNESS_TYPES_WITH_QUOTE_HASH;
+    } });
     var escrow_abi_1 = require_escrow_abi();
     Object.defineProperty(exports2, "ESCROW_ABI", { enumerable: true, get: function() {
       return escrow_abi_1.ESCROW_ABI;
@@ -840,6 +1723,27 @@ var require_dist2 = __commonJS({
     Object.defineProperty(exports2, "computeReserveDigest", { enumerable: true, get: function() {
       return reserve_encoder_1.computeReserveDigest;
     } });
+    var reserve_encoder_2 = require_reserve_encoder2();
+    Object.defineProperty(exports2, "buildReserveTypedDataWithQuoteSource", { enumerable: true, get: function() {
+      return reserve_encoder_2.buildReserveTypedDataWithQuoteSource;
+    } });
+    Object.defineProperty(exports2, "computeReserveDigestWithQuoteSource", { enumerable: true, get: function() {
+      return reserve_encoder_2.computeReserveDigestWithQuoteSource;
+    } });
+    var release_encoder_1 = require_release_encoder2();
+    Object.defineProperty(exports2, "buildReleaseTypedDataWithQuoteHash", { enumerable: true, get: function() {
+      return release_encoder_1.buildReleaseTypedDataWithQuoteHash;
+    } });
+    Object.defineProperty(exports2, "computeReleaseDigestWithQuoteHash", { enumerable: true, get: function() {
+      return release_encoder_1.computeReleaseDigestWithQuoteHash;
+    } });
+    var refund_encoder_1 = require_refund_encoder2();
+    Object.defineProperty(exports2, "buildRefundTypedDataWithQuoteHash", { enumerable: true, get: function() {
+      return refund_encoder_1.buildRefundTypedDataWithQuoteHash;
+    } });
+    Object.defineProperty(exports2, "computeRefundDigestWithQuoteHash", { enumerable: true, get: function() {
+      return refund_encoder_1.computeRefundDigestWithQuoteHash;
+    } });
     var deposit_encoder_1 = require_deposit_encoder2();
     Object.defineProperty(exports2, "createPermitWitnessTransferFromPrehash", { enumerable: true, get: function() {
       return deposit_encoder_1.createPermitWitnessTransferFromPrehash;
@@ -850,6 +1754,13 @@ var require_dist2 = __commonJS({
     Object.defineProperty(exports2, "PERMIT2_CONTRACT_ADDRESS", { enumerable: true, get: function() {
       return deposit_encoder_1.PERMIT2_CONTRACT_ADDRESS;
     } });
+    var deposit_encoder_2 = require_deposit_encoder2();
+    Object.defineProperty(exports2, "createPermitWitnessTransferFromPrehashWithDestination", { enumerable: true, get: function() {
+      return deposit_encoder_2.createPermitWitnessTransferFromPrehashWithDestination;
+    } });
+    Object.defineProperty(exports2, "MAX_DESTINATION_BYTES", { enumerable: true, get: function() {
+      return deposit_encoder_2.MAX_DESTINATION_BYTES;
+    } });
   }
 });
 
@@ -890,24 +1801,25 @@ var require_evm = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.evmAdapter = void 0;
     var ethers_1 = require("ethers");
-    var evm_escrow_encoding_1 = require_dist2();
+    var evm_escrow_encoding_1 = require_dist3();
     var utils_js_1 = require_utils();
+    var destination_js_1 = require_destination();
     var errors_js_1 = require_errors();
     var chain_id_js_1 = require_chain_id2();
     exports2.evmAdapter = {
-      async buildAuthMessage({ sourceAsset, maxSourceAmount, sourceDefaults, deadline, nonce }) {
+      async buildAuthMessage({ sourceAsset, maxSourceAmount, requestId, sourceDefaults, destinationAsset, destinationAccount, deadline, nonce }) {
         if (nonce === void 0) {
-          throw new Error("sender_auth: buildAuthMessage requires an explicit nonce \u2014 derive it deterministically from a stable request id (e.g. the challenge id) so retries reproduce the same permit; pass generatePermitNonce() only for genuinely one-shot builds");
+          throw new Error("sender_auth: buildAuthMessage requires an explicit nonce \u2014 derive it deterministically from a stable request id (e.g. an order id) so retries reproduce the same permit; pass generatePermitNonce() only for genuinely one-shot builds");
         }
         if (deadline === void 0) {
           throw new Error("sender_auth: buildAuthMessage requires an explicit permit deadline (absolute Unix seconds) \u2014 the low-level builder does not default it; derive it from the payment's fulfillment/settlement deadline in the calling layer (pgc/mppx)");
         }
-        const sourceChainId = sourceAsset.split("/")[0];
-        const chainIdNum = parseInt(sourceChainId.split(":")[1]);
-        const tokenAddress = sourceAsset.split("/")[1].split(":")[1];
-        const permitParams = {
+        const { network: sourceChainId, asset: tokenAddress } = (0, utils_js_1.parseSourceAsset)(sourceAsset);
+        const chainIdNum = (0, chain_id_js_1.evmChainId)(sourceChainId);
+        const permit2Contract = sourceDefaults.permit2Contract ?? evm_escrow_encoding_1.PERMIT2_CONTRACT_ADDRESS;
+        const basePermit = {
           chainId: chainIdNum,
-          verifyingContract: evm_escrow_encoding_1.PERMIT2_CONTRACT_ADDRESS,
+          verifyingContract: permit2Contract,
           token: tokenAddress,
           amount: maxSourceAmount,
           spender: sourceDefaults.escrowContract,
@@ -916,7 +1828,21 @@ var require_evm = __commonJS({
           reserver: sourceDefaults.quoteSelector,
           releaser: sourceDefaults.fulfillmentVerifierAccount
         };
-        const messagePrehash = (0, evm_escrow_encoding_1.createPermitWitnessTransferFromPrehash)(permitParams);
+        if ((0, destination_js_1.usesDestinationCommitment)(sourceDefaults.depositWitnessVersion)) {
+          const permitParams = {
+            ...basePermit,
+            // The two escrow commitments. Composed here through the shared helpers rather than
+            // accepted pre-built, so this producer and the release signer cannot disagree about
+            // formatting — a disagreement the escrow cannot detect, because it stores only
+            // keccak256(bytes(destination)).
+            depositRequestHash: (0, destination_js_1.deriveDepositRequestHash)(requestId),
+            destination: (0, destination_js_1.buildEscrowDestination)(destinationAsset, destinationAccount)
+          };
+          const messagePrehash2 = (0, evm_escrow_encoding_1.createPermitWitnessTransferFromPrehashWithDestination)(permitParams);
+          const messageHash2 = (0, evm_escrow_encoding_1.hashPermitWitnessTransferFrom)(messagePrehash2);
+          return { messageScheme: "EVM_PERMIT2", messageHash: messageHash2, messagePrehash: JSON.stringify(messagePrehash2) };
+        }
+        const messagePrehash = (0, evm_escrow_encoding_1.createPermitWitnessTransferFromPrehash)(basePermit);
         const messageHash = (0, evm_escrow_encoding_1.hashPermitWitnessTransferFrom)(messagePrehash);
         return { messageScheme: "EVM_PERMIT2", messageHash, messagePrehash: JSON.stringify(messagePrehash) };
       },
@@ -925,6 +1851,10 @@ var require_evm = __commonJS({
           throw new Error("EVM adapter sign(): signed_messages[i].message_prehash is required");
         }
         const prehash = JSON.parse(signedMessage.message_prehash);
+        const prehashDigest = (0, evm_escrow_encoding_1.hashPermitWitnessTransferFrom)(prehash);
+        if (prehashDigest.toLowerCase() !== signedMessage.message.toLowerCase()) {
+          throw new Error(`EVM adapter sign(): message_prehash implies digest ${prehashDigest} but message is ${signedMessage.message}`);
+        }
         const wallet = new ethers_1.Wallet(privateKey);
         return wallet.signTypedData(prehash.domain, prehash.types, prehash.message);
       },
@@ -945,17 +1875,31 @@ var require_evm = __commonJS({
         let msg;
         try {
           msg = JSON.parse(signed.message_prehash).message;
-          canonical = (0, evm_escrow_encoding_1.createPermitWitnessTransferFromPrehash)({
+          const base = {
             chainId: (0, chain_id_js_1.evmChainId)(source.network),
-            verifyingContract: evm_escrow_encoding_1.PERMIT2_CONTRACT_ADDRESS,
+            // The same Permit2 buildAuthMessage signed against. Taken from the VERIFIER's
+            // expectations, never from msg — the prehash is client-supplied, so reading the domain
+            // out of it would let a caller nominate its own verifying contract and have the
+            // signature check itself. Absent means canonical, matching the build side's default.
+            verifyingContract: expected.permit2Contract ?? evm_escrow_encoding_1.PERMIT2_CONTRACT_ADDRESS,
             token: msg.permitted.token,
             amount: msg.permitted.amount,
             spender: msg.spender,
             nonce: BigInt(msg.nonce),
             deadline: BigInt(msg.deadline),
-            reserver: msg.witness.reserver,
-            releaser: msg.witness.releaser
-          });
+            reserver: msg.witness?.reserver,
+            releaser: msg.witness?.releaser
+          };
+          const hasHash = typeof msg.witness?.depositRequestHash === "string";
+          const hasDestination = typeof msg.witness?.destination === "string";
+          if (hasHash !== hasDestination) {
+            throw new Error("half-populated deposit witness");
+          }
+          canonical = hasHash ? (0, evm_escrow_encoding_1.createPermitWitnessTransferFromPrehashWithDestination)({
+            ...base,
+            depositRequestHash: msg.witness.depositRequestHash,
+            destination: msg.witness.destination
+          }) : (0, evm_escrow_encoding_1.createPermitWitnessTransferFromPrehash)(base);
         } catch {
           throw new errors_js_1.MalformedPrehashError();
         }
@@ -979,6 +1923,12 @@ var require_evm = __commonJS({
         if (expected.reserver !== void 0 && expected.releaser !== void 0) {
           (0, utils_js_1.assertWitnessRoles)(msg.witness.reserver, msg.witness.releaser, expected.reserver, expected.releaser, (a) => a);
         }
+        if (expected.destination !== void 0) {
+          (0, utils_js_1.assertDestination)(msg.witness.destination, expected.destination);
+        }
+        if (expected.requestId !== void 0) {
+          (0, utils_js_1.assertDepositRequestHash)(msg.witness.depositRequestHash, expected.requestId);
+        }
         return {
           amount: msg.permitted.amount,
           deadlineSec,
@@ -989,7 +1939,11 @@ var require_evm = __commonJS({
             deadlineSec,
             reserver: msg.witness.reserver,
             releaser: msg.witness.releaser,
-            spender: msg.spender
+            spender: msg.spender,
+            // Surfaced whether or not the opt-in checks above ran, so a consumer binding these
+            // downstream does not have to re-parse message_prehash and risk drifting from this parse.
+            destination: msg.witness.destination,
+            depositRequestHash: msg.witness.depositRequestHash
           }
         };
       }
@@ -1008,18 +1962,18 @@ var require_tron = __commonJS({
     var utils_js_1 = require_utils();
     var errors_js_1 = require_errors();
     var chain_id_js_1 = require_chain_id2();
+    var destination_js_1 = require_destination();
     exports2.tronAdapter = {
-      async buildAuthMessage({ sourceAsset, maxSourceAmount, sourceDefaults, deadline, nonce }) {
+      async buildAuthMessage({ sourceAsset, maxSourceAmount, requestId, sourceDefaults, destinationAsset, destinationAccount, deadline, nonce }) {
         if (nonce === void 0) {
-          throw new Error("sender_auth: buildAuthMessage requires an explicit nonce \u2014 derive it deterministically from a stable request id (e.g. the challenge id) so retries reproduce the same permit; pass generatePermitNonce() only for genuinely one-shot builds");
+          throw new Error("sender_auth: buildAuthMessage requires an explicit nonce \u2014 derive it deterministically from a stable request id (e.g. an order id) so retries reproduce the same permit; pass generatePermitNonce() only for genuinely one-shot builds");
         }
         if (deadline === void 0) {
           throw new Error("sender_auth: buildAuthMessage requires an explicit permit deadline (absolute Unix seconds) \u2014 the low-level builder does not default it; derive it from the payment's fulfillment/settlement deadline in the calling layer (pgc/mppx)");
         }
-        const sourceChainId = sourceAsset.split("/")[0];
-        const tokenAddress = sourceAsset.split("/")[1].split(":")[1];
+        const { network: sourceChainId, asset: tokenAddress } = (0, utils_js_1.parseSourceAsset)(sourceAsset);
         const permit2Address = sourceDefaults.permit2Contract ?? (0, chain_id_js_1.resolveTronPermit2)(sourceChainId);
-        const tvmParams = {
+        const baseParams = {
           chainId: (0, chain_id_js_1.tronNumericChainId)(sourceChainId),
           permit2Address,
           tokenAddress,
@@ -1030,13 +1984,37 @@ var require_tron = __commonJS({
           reserverAddress: sourceDefaults.quoteSelector,
           releaserAddress: sourceDefaults.fulfillmentVerifierAccount
         };
-        const messagePrehash = (0, tvm_escrow_encoding_1.createTvmPermitWitnessTransferFromPrehash)(tvmParams);
+        if ((0, destination_js_1.usesDestinationCommitment)(sourceDefaults.depositWitnessVersion)) {
+          const tvmParams = {
+            ...baseParams,
+            // The two commitments, composed through the shared helpers rather than accepted
+            // pre-built, so this producer and the Go release signer cannot disagree about
+            // formatting — a disagreement the escrow cannot detect, because it stores only
+            // keccak256(bytes(destination)).
+            depositRequestHash: (0, destination_js_1.deriveDepositRequestHash)(requestId),
+            destination: (0, destination_js_1.buildEscrowDestination)(destinationAsset, destinationAccount)
+          };
+          const messagePrehash2 = (0, tvm_escrow_encoding_1.createTvmPermitWitnessTransferFromPrehashWithDestination)(tvmParams);
+          const messageHash2 = (0, tvm_escrow_encoding_1.hashTvmPermitWitnessTransferFrom)(messagePrehash2);
+          return { messageScheme: "EVM_PERMIT2", messageHash: messageHash2, messagePrehash: JSON.stringify(messagePrehash2) };
+        }
+        const messagePrehash = (0, tvm_escrow_encoding_1.createTvmPermitWitnessTransferFromPrehash)(baseParams);
         const messageHash = (0, tvm_escrow_encoding_1.hashTvmPermitWitnessTransferFrom)(messagePrehash);
         return { messageScheme: "EVM_PERMIT2", messageHash, messagePrehash: JSON.stringify(messagePrehash) };
       },
+      // Signs the TIP-712 typed data, not the bare digest, so a signer can inspect the fields it is
+      // authorizing (Turnkey policies read `eth.eip_712.message[...]`).
       async sign(signedMessage, privateKey) {
+        if (!signedMessage.message_prehash) {
+          throw new Error("Tron adapter sign(): signed_messages[i].message_prehash is required");
+        }
+        const prehash = JSON.parse(signedMessage.message_prehash);
+        const prehashDigest = (0, tvm_escrow_encoding_1.hashTvmPermitWitnessTransferFrom)(prehash);
+        if (prehashDigest.toLowerCase() !== signedMessage.message.toLowerCase()) {
+          throw new Error(`Tron adapter sign(): message_prehash implies digest ${prehashDigest} but message is ${signedMessage.message}`);
+        }
         const wallet = new ethers_1.Wallet(privateKey.startsWith("0x") ? privateKey : "0x" + privateKey);
-        return wallet.signingKey.sign(signedMessage.message).serialized;
+        return wallet.signTypedData(prehash.domain, prehash.types, prehash.message);
       },
       recoverSigner(signed, source) {
         let recovered;
@@ -1055,17 +2033,31 @@ var require_tron = __commonJS({
         let digest;
         try {
           msg = JSON.parse(signed.message_prehash).message;
-          const canonical = (0, tvm_escrow_encoding_1.createTvmPermitWitnessTransferFromPrehash)({
+          const base = {
             chainId: (0, chain_id_js_1.tronNumericChainId)(source.network),
-            permit2Address: (0, chain_id_js_1.resolveTronPermit2)(source.network),
+            // The same Permit2 buildAuthMessage signed against, taken from the VERIFIER's
+            // expectations rather than from msg — the prehash is payer-supplied, so reading the
+            // domain out of it would let a caller nominate its own verifying contract. Absent means
+            // the pinned per-chain address, matching the build side's default.
+            permit2Address: expected.permit2Contract ?? (0, chain_id_js_1.resolveTronPermit2)(source.network),
             tokenAddress: msg.permitted.token,
             amount: msg.permitted.amount,
             spenderAddress: msg.spender,
             nonce: BigInt(msg.nonce),
             deadline: BigInt(msg.deadline),
-            reserverAddress: msg.witness.reserver,
-            releaserAddress: msg.witness.releaser
-          });
+            reserverAddress: msg.witness?.reserver,
+            releaserAddress: msg.witness?.releaser
+          };
+          const hasHash = typeof msg.witness?.depositRequestHash === "string";
+          const hasDestination = typeof msg.witness?.destination === "string";
+          if (hasHash !== hasDestination) {
+            throw new Error("half-populated witness");
+          }
+          const canonical = hasHash ? (0, tvm_escrow_encoding_1.createTvmPermitWitnessTransferFromPrehashWithDestination)({
+            ...base,
+            depositRequestHash: msg.witness.depositRequestHash,
+            destination: msg.witness.destination
+          }) : (0, tvm_escrow_encoding_1.createTvmPermitWitnessTransferFromPrehash)(base);
           digest = (0, tvm_escrow_encoding_1.hashTvmPermitWitnessTransferFrom)(canonical);
         } catch {
           throw new errors_js_1.MalformedPrehashError();
@@ -1113,7 +2105,7 @@ var require_errors2 = __commonJS({
   "../contracts/svm/escrow-encoding/typescript/dist/errors.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.InvalidHexError = exports2.InvalidBase58Error = exports2.InvalidPubkeyLengthError = exports2.ZeroDepositHashError = exports2.ZeroRecipientError = exports2.ZeroReleaserError = exports2.ZeroReserverError = exports2.ZeroAmountError = exports2.ZeroMintError = exports2.ZeroDepositorError = exports2.ZeroPaymentIdError = exports2.EncodingError = void 0;
+    exports2.DestinationTooLongError = exports2.EmptyDestinationError = exports2.ZeroSourceAmountError = exports2.ZeroQuoteHashError = exports2.InvalidHexError = exports2.InvalidBase58Error = exports2.InvalidPubkeyLengthError = exports2.ZeroDepositHashError = exports2.ZeroRecipientError = exports2.ZeroReleaserError = exports2.ZeroReserverError = exports2.ZeroAmountError = exports2.ZeroMintError = exports2.ZeroDepositorError = exports2.ZeroDepositRequestHashError = exports2.EncodingError = void 0;
     var EncodingError = class extends Error {
       constructor(message) {
         super(message);
@@ -1121,13 +2113,13 @@ var require_errors2 = __commonJS({
       }
     };
     exports2.EncodingError = EncodingError;
-    var ZeroPaymentIdError = class extends EncodingError {
+    var ZeroDepositRequestHashError = class extends EncodingError {
       constructor() {
-        super("payment ID cannot be zero");
-        this.name = "ZeroPaymentIdError";
+        super("deposit request hash cannot be zero");
+        this.name = "ZeroDepositRequestHashError";
       }
     };
-    exports2.ZeroPaymentIdError = ZeroPaymentIdError;
+    exports2.ZeroDepositRequestHashError = ZeroDepositRequestHashError;
     var ZeroDepositorError = class extends EncodingError {
       constructor() {
         super("depositor cannot be zero");
@@ -1198,6 +2190,34 @@ var require_errors2 = __commonJS({
       }
     };
     exports2.InvalidHexError = InvalidHexError;
+    var ZeroQuoteHashError = class extends EncodingError {
+      constructor() {
+        super("quote hash cannot be zero");
+        this.name = "ZeroQuoteHashError";
+      }
+    };
+    exports2.ZeroQuoteHashError = ZeroQuoteHashError;
+    var ZeroSourceAmountError = class extends EncodingError {
+      constructor() {
+        super("source amount cannot be zero");
+        this.name = "ZeroSourceAmountError";
+      }
+    };
+    exports2.ZeroSourceAmountError = ZeroSourceAmountError;
+    var EmptyDestinationError = class extends EncodingError {
+      constructor() {
+        super("destination cannot be empty");
+        this.name = "EmptyDestinationError";
+      }
+    };
+    exports2.EmptyDestinationError = EmptyDestinationError;
+    var DestinationTooLongError = class extends EncodingError {
+      constructor() {
+        super("destination exceeds the maximum length");
+        this.name = "DestinationTooLongError";
+      }
+    };
+    exports2.DestinationTooLongError = DestinationTooLongError;
   }
 });
 
@@ -1212,7 +2232,7 @@ var require_pubkey = __commonJS({
     exports2.Pubkey = void 0;
     var bs58_1 = __importDefault(require("bs58"));
     var errors_1 = require_errors2();
-    var Pubkey2 = class _Pubkey {
+    var Pubkey = class _Pubkey {
       constructor(data) {
         if (data.length !== 32) {
           throw new errors_1.InvalidPubkeyLengthError();
@@ -1305,7 +2325,7 @@ var require_pubkey = __commonJS({
         return this.data.every((b, i) => b === other.data[i]);
       }
     };
-    exports2.Pubkey = Pubkey2;
+    exports2.Pubkey = Pubkey;
   }
 });
 
@@ -1928,13 +2948,16 @@ var require_deposit_encoder3 = __commonJS({
   "../contracts/svm/escrow-encoding/typescript/dist/deposit-encoder.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.computeDepositHash = computeDepositHash2;
+    exports2.MAX_DESTINATION_LEN = void 0;
+    exports2.computeDepositHash = computeDepositHash;
+    exports2.computeDestinationHash = computeDestinationHash;
+    exports2.computeDepositHashV2 = computeDepositHashV2;
     var encoding_utils_1 = require_encoding_utils();
     var escrow_domain_1 = require_escrow_domain();
     var errors_1 = require_errors2();
-    function computeDepositHash2(params, domain) {
-      if (params.paymentId.length !== 32 || (0, encoding_utils_1.isZeroBytes32)(params.paymentId)) {
-        throw new errors_1.ZeroPaymentIdError();
+    function computeDepositHash(params, domain) {
+      if (params.depositRequestHash.length !== 32 || (0, encoding_utils_1.isZeroBytes32)(params.depositRequestHash)) {
+        throw new errors_1.ZeroDepositRequestHashError();
       }
       if (params.depositor.isZero())
         throw new errors_1.ZeroDepositorError();
@@ -1946,7 +2969,48 @@ var require_deposit_encoder3 = __commonJS({
         throw new errors_1.ZeroReserverError();
       if (params.releaser.isZero())
         throw new errors_1.ZeroReleaserError();
-      return (0, encoding_utils_1.keccak256)(...(0, escrow_domain_1.escrowDomainPrefixBytes)(domain), (0, encoding_utils_1.stringToBytes)("deposit"), params.paymentId, params.depositor.toBytes(), params.mint.toBytes(), (0, encoding_utils_1.encodeU64LE)(params.amount), params.reserver.toBytes(), params.releaser.toBytes(), (0, encoding_utils_1.encodeU64LE)(params.nonce), (0, encoding_utils_1.encodeU64LE)(params.issuedAt), (0, encoding_utils_1.encodeU64LE)(params.deadline));
+      return (0, encoding_utils_1.keccak256)(...(0, escrow_domain_1.escrowDomainPrefixBytes)(domain), (0, encoding_utils_1.stringToBytes)("deposit"), params.depositRequestHash, params.depositor.toBytes(), params.mint.toBytes(), (0, encoding_utils_1.encodeU64LE)(params.amount), params.reserver.toBytes(), params.releaser.toBytes(), (0, encoding_utils_1.encodeU64LE)(params.nonce), (0, encoding_utils_1.encodeU64LE)(params.issuedAt), (0, encoding_utils_1.encodeU64LE)(params.deadline));
+    }
+    exports2.MAX_DESTINATION_LEN = 256;
+    function computeDestinationHash(destination) {
+      return (0, encoding_utils_1.keccak256)((0, encoding_utils_1.stringToBytes)(destination));
+    }
+    function computeDepositHashV2(params, destination, domain) {
+      if (params.depositRequestHash.length !== 32 || (0, encoding_utils_1.isZeroBytes32)(params.depositRequestHash)) {
+        throw new errors_1.ZeroDepositRequestHashError();
+      }
+      if (params.depositor.isZero())
+        throw new errors_1.ZeroDepositorError();
+      if (params.mint.isZero())
+        throw new errors_1.ZeroMintError();
+      if (params.amount === 0n)
+        throw new errors_1.ZeroAmountError();
+      if (params.reserver.isZero())
+        throw new errors_1.ZeroReserverError();
+      if (params.releaser.isZero())
+        throw new errors_1.ZeroReleaserError();
+      if (destination.length === 0)
+        throw new errors_1.EmptyDestinationError();
+      if ((0, encoding_utils_1.stringToBytes)(destination).length > exports2.MAX_DESTINATION_LEN) {
+        throw new errors_1.DestinationTooLongError();
+      }
+      return (0, encoding_utils_1.keccak256)(
+        ...(0, escrow_domain_1.escrowDomainPrefixBytes)(domain),
+        (0, encoding_utils_1.stringToBytes)("deposit"),
+        params.depositRequestHash,
+        // Hash first: keccak256 concatenates without length prefixes, so injectivity depends on every
+        // hashed field being fixed-width. Feeding the raw string would make it conditional on the
+        // surrounding widths and diverge from the on-chain program, which hashes it too.
+        computeDestinationHash(destination),
+        params.depositor.toBytes(),
+        params.mint.toBytes(),
+        (0, encoding_utils_1.encodeU64LE)(params.amount),
+        params.reserver.toBytes(),
+        params.releaser.toBytes(),
+        (0, encoding_utils_1.encodeU64LE)(params.nonce),
+        (0, encoding_utils_1.encodeU64LE)(params.issuedAt),
+        (0, encoding_utils_1.encodeU64LE)(params.deadline)
+      );
     }
   }
 });
@@ -1957,6 +3021,8 @@ var require_reserve_encoder3 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.computeReserveHash = computeReserveHash;
+    exports2.computeReserveHashV2 = computeReserveHashV2;
+    exports2.computeReserveHashV3 = computeReserveHashV3;
     var encoding_utils_1 = require_encoding_utils();
     var escrow_domain_1 = require_escrow_domain();
     var errors_1 = require_errors2();
@@ -1968,15 +3034,38 @@ var require_reserve_encoder3 = __commonJS({
         throw new errors_1.ZeroRecipientError();
       return (0, encoding_utils_1.keccak256)(...(0, escrow_domain_1.escrowDomainPrefixBytes)(domain), (0, encoding_utils_1.stringToBytes)("reserve"), params.recipient.toBytes(), params.depositHash);
     }
+    function computeReserveHashV2(params, quoteHash, domain) {
+      if (params.depositHash.length !== 32 || (0, encoding_utils_1.isZeroBytes32)(params.depositHash)) {
+        throw new errors_1.ZeroDepositHashError();
+      }
+      if (params.recipient.isZero())
+        throw new errors_1.ZeroRecipientError();
+      if (quoteHash.length !== 32 || (0, encoding_utils_1.isZeroBytes32)(quoteHash))
+        throw new errors_1.ZeroQuoteHashError();
+      return (0, encoding_utils_1.keccak256)(...(0, escrow_domain_1.escrowDomainPrefixBytes)(domain), (0, encoding_utils_1.stringToBytes)("reserve"), params.recipient.toBytes(), params.depositHash, quoteHash);
+    }
+    function computeReserveHashV3(params, quoteHash, sourceAmount, domain) {
+      if (params.depositHash.length !== 32 || (0, encoding_utils_1.isZeroBytes32)(params.depositHash)) {
+        throw new errors_1.ZeroDepositHashError();
+      }
+      if (params.recipient.isZero())
+        throw new errors_1.ZeroRecipientError();
+      if (quoteHash.length !== 32 || (0, encoding_utils_1.isZeroBytes32)(quoteHash))
+        throw new errors_1.ZeroQuoteHashError();
+      if (sourceAmount === 0n)
+        throw new errors_1.ZeroSourceAmountError();
+      return (0, encoding_utils_1.keccak256)(...(0, escrow_domain_1.escrowDomainPrefixBytes)(domain), (0, encoding_utils_1.stringToBytes)("reserve"), params.recipient.toBytes(), params.depositHash, quoteHash, (0, encoding_utils_1.encodeU64LE)(sourceAmount));
+    }
   }
 });
 
 // ../contracts/svm/escrow-encoding/typescript/dist/release-encoder.js
-var require_release_encoder = __commonJS({
+var require_release_encoder3 = __commonJS({
   "../contracts/svm/escrow-encoding/typescript/dist/release-encoder.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.computeReleaseHash = computeReleaseHash;
+    exports2.computeReleaseHashV2 = computeReleaseHashV2;
     var encoding_utils_1 = require_encoding_utils();
     var escrow_domain_1 = require_escrow_domain();
     var errors_1 = require_errors2();
@@ -1986,15 +3075,22 @@ var require_release_encoder = __commonJS({
       }
       return (0, encoding_utils_1.keccak256)(...(0, escrow_domain_1.escrowDomainPrefixBytes)(domain), (0, encoding_utils_1.stringToBytes)("release"), params.depositHash);
     }
+    function computeReleaseHashV2(params, quoteHash, domain) {
+      if (params.depositHash.length !== 32 || (0, encoding_utils_1.isZeroBytes32)(params.depositHash)) {
+        throw new errors_1.ZeroDepositHashError();
+      }
+      return (0, encoding_utils_1.keccak256)(...(0, escrow_domain_1.escrowDomainPrefixBytes)(domain), (0, encoding_utils_1.stringToBytes)("release"), params.depositHash, quoteHash);
+    }
   }
 });
 
 // ../contracts/svm/escrow-encoding/typescript/dist/refund-encoder.js
-var require_refund_encoder = __commonJS({
+var require_refund_encoder3 = __commonJS({
   "../contracts/svm/escrow-encoding/typescript/dist/refund-encoder.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.computeRefundHash = computeRefundHash;
+    exports2.computeRefundHashV2 = computeRefundHashV2;
     var encoding_utils_1 = require_encoding_utils();
     var escrow_domain_1 = require_escrow_domain();
     var errors_1 = require_errors2();
@@ -2004,6 +3100,12 @@ var require_refund_encoder = __commonJS({
       }
       return (0, encoding_utils_1.keccak256)(...(0, escrow_domain_1.escrowDomainPrefixBytes)(domain), (0, encoding_utils_1.stringToBytes)("refund"), params.depositHash);
     }
+    function computeRefundHashV2(params, quoteHash, domain) {
+      if (params.depositHash.length !== 32 || (0, encoding_utils_1.isZeroBytes32)(params.depositHash)) {
+        throw new errors_1.ZeroDepositHashError();
+      }
+      return (0, encoding_utils_1.keccak256)(...(0, escrow_domain_1.escrowDomainPrefixBytes)(domain), (0, encoding_utils_1.stringToBytes)("refund"), params.depositHash, quoteHash);
+    }
   }
 });
 
@@ -2012,16 +3114,16 @@ var require_nonce_generator2 = __commonJS({
   "../contracts/svm/escrow-encoding/typescript/dist/nonce-generator.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.MAX_VALID_SLOT = exports2.REPLAY_SLOTS = void 0;
+    exports2.REPLAY_BUCKETS = exports2.MAX_VALID_SLOT = exports2.REPLAY_SLOTS = exports2.DEPOSIT_COMPUTE_UNIT_LIMIT = void 0;
     exports2.generateNonce = generateNonce2;
     var crypto_1 = require("crypto");
+    exports2.DEPOSIT_COMPUTE_UNIT_LIMIT = 4e5;
     exports2.REPLAY_SLOTS = 235;
     exports2.MAX_VALID_SLOT = exports2.REPLAY_SLOTS - 1;
-    var NONCE_BUCKET_MASK = 131071;
+    exports2.REPLAY_BUCKETS = 256;
     var NONCE_BUCKET_SHIFT = 32n;
     function generateNonce2() {
-      const bucketBytes = (0, crypto_1.randomBytes)(4);
-      const bucketID = bucketBytes.readUInt32LE(0) & NONCE_BUCKET_MASK;
+      const bucketID = (0, crypto_1.randomBytes)(4).readUInt32LE(0) % exports2.REPLAY_BUCKETS;
       let slot;
       do {
         slot = (0, crypto_1.randomBytes)(1)[0];
@@ -2032,11 +3134,11 @@ var require_nonce_generator2 = __commonJS({
 });
 
 // ../contracts/svm/escrow-encoding/typescript/dist/index.js
-var require_dist3 = __commonJS({
+var require_dist4 = __commonJS({
   "../contracts/svm/escrow-encoding/typescript/dist/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.MAX_VALID_SLOT = exports2.REPLAY_SLOTS = exports2.generateNonce = exports2.computeRefundHash = exports2.computeReleaseHash = exports2.computeReserveHash = exports2.computeDepositHash = exports2.InvalidHexError = exports2.InvalidBase58Error = exports2.InvalidPubkeyLengthError = exports2.ZeroDepositHashError = exports2.ZeroRecipientError = exports2.ZeroReleaserError = exports2.ZeroReserverError = exports2.ZeroAmountError = exports2.ZeroMintError = exports2.ZeroDepositorError = exports2.ZeroPaymentIdError = exports2.EncodingError = exports2.escrowDomainPrefixBytes = exports2.isZeroBytes32 = exports2.stringToBytes = exports2.keccak256 = exports2.encodeU64LE = exports2.Pubkey = void 0;
+    exports2.DEPOSIT_COMPUTE_UNIT_LIMIT = exports2.REPLAY_BUCKETS = exports2.MAX_VALID_SLOT = exports2.REPLAY_SLOTS = exports2.generateNonce = exports2.computeRefundHashV2 = exports2.computeRefundHash = exports2.computeReleaseHashV2 = exports2.computeReleaseHash = exports2.computeReserveHashV3 = exports2.computeReserveHashV2 = exports2.computeReserveHash = exports2.MAX_DESTINATION_LEN = exports2.computeDestinationHash = exports2.computeDepositHashV2 = exports2.computeDepositHash = exports2.InvalidHexError = exports2.InvalidBase58Error = exports2.InvalidPubkeyLengthError = exports2.ZeroDepositHashError = exports2.ZeroRecipientError = exports2.ZeroReleaserError = exports2.ZeroReserverError = exports2.ZeroAmountError = exports2.ZeroMintError = exports2.ZeroDepositorError = exports2.DestinationTooLongError = exports2.EmptyDestinationError = exports2.ZeroQuoteHashError = exports2.ZeroDepositRequestHashError = exports2.EncodingError = exports2.escrowDomainPrefixBytes = exports2.isZeroBytes32 = exports2.stringToBytes = exports2.keccak256 = exports2.encodeU64LE = exports2.Pubkey = void 0;
     var pubkey_1 = require_pubkey();
     Object.defineProperty(exports2, "Pubkey", { enumerable: true, get: function() {
       return pubkey_1.Pubkey;
@@ -2062,8 +3164,17 @@ var require_dist3 = __commonJS({
     Object.defineProperty(exports2, "EncodingError", { enumerable: true, get: function() {
       return errors_1.EncodingError;
     } });
-    Object.defineProperty(exports2, "ZeroPaymentIdError", { enumerable: true, get: function() {
-      return errors_1.ZeroPaymentIdError;
+    Object.defineProperty(exports2, "ZeroDepositRequestHashError", { enumerable: true, get: function() {
+      return errors_1.ZeroDepositRequestHashError;
+    } });
+    Object.defineProperty(exports2, "ZeroQuoteHashError", { enumerable: true, get: function() {
+      return errors_1.ZeroQuoteHashError;
+    } });
+    Object.defineProperty(exports2, "EmptyDestinationError", { enumerable: true, get: function() {
+      return errors_1.EmptyDestinationError;
+    } });
+    Object.defineProperty(exports2, "DestinationTooLongError", { enumerable: true, get: function() {
+      return errors_1.DestinationTooLongError;
     } });
     Object.defineProperty(exports2, "ZeroDepositorError", { enumerable: true, get: function() {
       return errors_1.ZeroDepositorError;
@@ -2099,18 +3210,39 @@ var require_dist3 = __commonJS({
     Object.defineProperty(exports2, "computeDepositHash", { enumerable: true, get: function() {
       return deposit_encoder_1.computeDepositHash;
     } });
+    Object.defineProperty(exports2, "computeDepositHashV2", { enumerable: true, get: function() {
+      return deposit_encoder_1.computeDepositHashV2;
+    } });
+    Object.defineProperty(exports2, "computeDestinationHash", { enumerable: true, get: function() {
+      return deposit_encoder_1.computeDestinationHash;
+    } });
+    Object.defineProperty(exports2, "MAX_DESTINATION_LEN", { enumerable: true, get: function() {
+      return deposit_encoder_1.MAX_DESTINATION_LEN;
+    } });
     var reserve_encoder_1 = require_reserve_encoder3();
     Object.defineProperty(exports2, "computeReserveHash", { enumerable: true, get: function() {
       return reserve_encoder_1.computeReserveHash;
     } });
-    var release_encoder_1 = require_release_encoder();
+    Object.defineProperty(exports2, "computeReserveHashV2", { enumerable: true, get: function() {
+      return reserve_encoder_1.computeReserveHashV2;
+    } });
+    Object.defineProperty(exports2, "computeReserveHashV3", { enumerable: true, get: function() {
+      return reserve_encoder_1.computeReserveHashV3;
+    } });
+    var release_encoder_1 = require_release_encoder3();
     Object.defineProperty(exports2, "computeReleaseHash", { enumerable: true, get: function() {
       return release_encoder_1.computeReleaseHash;
     } });
-    var refund_encoder_1 = require_refund_encoder();
+    Object.defineProperty(exports2, "computeReleaseHashV2", { enumerable: true, get: function() {
+      return release_encoder_1.computeReleaseHashV2;
+    } });
+    var refund_encoder_1 = require_refund_encoder3();
     Object.defineProperty(exports2, "computeRefundHash", { enumerable: true, get: function() {
       return refund_encoder_1.computeRefundHash;
     } });
+    Object.defineProperty(exports2, "computeRefundHashV2", { enumerable: true, get: function() {
+      return refund_encoder_1.computeRefundHashV2;
+    } });
     var nonce_generator_1 = require_nonce_generator2();
     Object.defineProperty(exports2, "generateNonce", { enumerable: true, get: function() {
       return nonce_generator_1.generateNonce;
@@ -2121,6 +3253,12 @@ var require_dist3 = __commonJS({
     Object.defineProperty(exports2, "MAX_VALID_SLOT", { enumerable: true, get: function() {
       return nonce_generator_1.MAX_VALID_SLOT;
     } });
+    Object.defineProperty(exports2, "REPLAY_BUCKETS", { enumerable: true, get: function() {
+      return nonce_generator_1.REPLAY_BUCKETS;
+    } });
+    Object.defineProperty(exports2, "DEPOSIT_COMPUTE_UNIT_LIMIT", { enumerable: true, get: function() {
+      return nonce_generator_1.DEPOSIT_COMPUTE_UNIT_LIMIT;
+    } });
   }
 });
 
@@ -2136,7 +3274,8 @@ var require_solana = __commonJS({
     var ethers_1 = require("ethers");
     var tweetnacl_1 = __importDefault(require("tweetnacl"));
     var bs58_1 = __importDefault(require("bs58"));
-    var solana_escrow_encoding_1 = require_dist3();
+    var solana_escrow_encoding_1 = require_dist4();
+    var destination_js_1 = require_destination();
     var utils_js_1 = require_utils();
     var errors_js_1 = require_errors();
     var chain_id_js_1 = require_chain_id2();
@@ -2146,7 +3285,8 @@ var require_solana = __commonJS({
     }
     function hashDeposit(prehash, domain) {
       return (0, ethers_1.hexlify)((0, solana_escrow_encoding_1.computeDepositHash)({
-        paymentId: (0, ethers_1.getBytes)(prehash.payment_id),
+        // The encoder field was renamed for cross-VM parity; the prehash WIRE key stays payment_id.
+        depositRequestHash: (0, ethers_1.getBytes)(prehash.payment_id),
         depositor: solana_escrow_encoding_1.Pubkey.fromBase58(prehash.depositor),
         mint: solana_escrow_encoding_1.Pubkey.fromBase58(prehash.mint),
         amount: BigInt(prehash.amount),
@@ -2157,6 +3297,26 @@ var require_solana = __commonJS({
         deadline: BigInt(prehash.deadline)
       }, domain));
     }
+    var SVM_DESTINATION_COMMITMENT_VERSION = 4;
+    function hashDepositV2(prehash, domain) {
+      return (0, ethers_1.hexlify)((0, solana_escrow_encoding_1.computeDepositHashV2)(
+        {
+          depositRequestHash: (0, ethers_1.getBytes)(prehash.deposit_request_hash),
+          depositor: solana_escrow_encoding_1.Pubkey.fromBase58(prehash.depositor),
+          mint: solana_escrow_encoding_1.Pubkey.fromBase58(prehash.mint),
+          amount: BigInt(prehash.amount),
+          reserver: solana_escrow_encoding_1.Pubkey.fromBase58(prehash.reserver),
+          releaser: solana_escrow_encoding_1.Pubkey.fromBase58(prehash.releaser),
+          nonce: BigInt(prehash.nonce),
+          issuedAt: BigInt(prehash.issued_at),
+          deadline: BigInt(prehash.deadline)
+        },
+        // Plaintext, NOT pre-hashed: the encoder hashes it, and hashing an already-hashed
+        // destination yields a well-formed commitment no on-chain state can satisfy.
+        prehash.destination,
+        domain
+      ));
+    }
     function domainFrom(defaults) {
       if (!defaults.escrowContract) {
         throw new Error("sender_auth: Solana source requires escrowContract (escrow program id) for the deposit-hash domain");
@@ -2171,12 +3331,11 @@ var require_solana = __commonJS({
       };
     }
     exports2.solanaAdapter = {
-      async buildAuthMessage({ sourceAsset, depositor, maxSourceAmount, requestId, sourceDefaults, nonce, solanaClockReader }) {
+      async buildAuthMessage({ sourceAsset, depositor, maxSourceAmount, requestId, sourceDefaults, destinationAsset, destinationAccount, nonce, solanaClockReader }) {
         if (!requestId) {
           throw new Error("sender_auth: request_id is required");
         }
-        const sourceChainId = sourceAsset.split("/")[0];
-        const tokenMint = sourceAsset.split("/")[1].split(":")[1];
+        const { network: sourceChainId, asset: tokenMint } = (0, utils_js_1.parseSourceAsset)(sourceAsset);
         const depositNonce = nonce !== void 0 ? BigInt(nonce) : (0, solana_escrow_encoding_1.generateNonce)();
         if (nonce !== void 0) {
           if (depositNonce < 0n || depositNonce >= 1n << 64n) {
@@ -2189,8 +3348,8 @@ var require_solana = __commonJS({
         const issuedAt = solanaClockReader ? await solanaClockReader(sourceChainId) : BigInt(Math.floor(Date.now() / 1e3));
         const deadline = issuedAt + BigInt(utils_js_1.REPLAY_HORIZON_SECS - 8);
         const paymentId = generateSolanaPaymentIdV3(requestId);
-        const prehash = {
-          payment_id: paymentId,
+        const domain = domainFrom(sourceDefaults);
+        const common = {
           depositor,
           mint: tokenMint,
           amount: BigInt(maxSourceAmount).toString(),
@@ -2200,7 +3359,20 @@ var require_solana = __commonJS({
           issued_at: issuedAt.toString(),
           deadline: deadline.toString()
         };
-        const depositHash = hashDeposit(prehash, domainFrom(sourceDefaults));
+        if (domain.signatureDomainVersion >= SVM_DESTINATION_COMMITMENT_VERSION) {
+          const prehashV2 = {
+            deposit_request_hash: paymentId,
+            destination: (0, destination_js_1.buildEscrowDestination)(destinationAsset, destinationAccount),
+            ...common
+          };
+          return {
+            messageScheme: "SOLANA",
+            messageHash: hashDepositV2(prehashV2, domain),
+            messagePrehash: JSON.stringify(prehashV2)
+          };
+        }
+        const prehash = { payment_id: paymentId, ...common };
+        const depositHash = hashDeposit(prehash, domain);
         return { messageScheme: "SOLANA", messageHash: depositHash, messagePrehash: JSON.stringify(prehash) };
       },
       async sign(signedMessage, privateKey) {
@@ -2246,8 +3418,18 @@ var require_solana = __commonJS({
         let prehash;
         let canonicalHash;
         try {
-          prehash = JSON.parse(signed.message_prehash);
-          canonicalHash = hashDeposit(prehash, domainFrom(expected));
+          const domain = domainFrom(expected);
+          if (domain.signatureDomainVersion >= SVM_DESTINATION_COMMITMENT_VERSION) {
+            const v2 = JSON.parse(signed.message_prehash);
+            if (typeof v2.deposit_request_hash !== "string" || typeof v2.destination !== "string") {
+              throw new Error("pre-widening V1 prehash on a destination-committing domain");
+            }
+            canonicalHash = hashDepositV2(v2, domain);
+            prehash = { payment_id: v2.deposit_request_hash, ...v2 };
+          } else {
+            prehash = JSON.parse(signed.message_prehash);
+            canonicalHash = hashDeposit(prehash, domain);
+          }
         } catch {
           throw new errors_js_1.MalformedPrehashError();
         }
@@ -2307,135 +3489,523 @@ var require_solana = __commonJS({
   }
 });
 
-// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/adapters/index.js
-var require_adapters = __commonJS({
-  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/adapters/index.js"(exports2) {
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/adapters/index.js
+var require_adapters = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/adapters/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getChainAdapter = getChainAdapter2;
+    var chain_id_js_1 = require_chain_id2();
+    var evm_js_1 = require_evm();
+    var tron_js_1 = require_tron();
+    var solana_js_1 = require_solana();
+    var adapters2 = {
+      eip155: evm_js_1.evmAdapter,
+      tron: tron_js_1.tronAdapter,
+      solana: solana_js_1.solanaAdapter
+    };
+    function getChainAdapter2(caip2) {
+      const adapter = adapters2[(0, chain_id_js_1.namespaceOf)(caip2)];
+      if (!adapter) {
+        throw new Error(`sender_auth: unsupported source chain '${caip2}'`);
+      }
+      return adapter;
+    }
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/verify.js
+var require_verify = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/verify.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.verifyPaymentRequest = verifyPaymentRequest;
+    var index_js_1 = require_adapters();
+    var utils_js_1 = require_utils();
+    function verifyPaymentRequest(request2, expected = {}) {
+      const senderAuth = request2.sender_auth;
+      if (!senderAuth?.signed_messages?.length) {
+        throw new Error("sender_auth: request has no signed_messages to verify");
+      }
+      if (!request2.source) {
+        throw new Error("sender_auth: request has no source");
+      }
+      const requestSource = (0, utils_js_1.parseSourceAsset)(request2.source.asset_identifier);
+      const { sourceAsset, network: networkOverride, maxSourceAmount: amountOverride, ...scheme } = expected;
+      const network = networkOverride ?? requestSource.network;
+      const asset = sourceAsset ?? requestSource.asset;
+      const maxSourceAmount = amountOverride ?? request2.max_source_amount ?? "0";
+      const source = { network, asset, account: request2.source.account };
+      const perMessage = { ...scheme, maxSourceAmount };
+      const adapter = (0, index_js_1.getChainAdapter)(network);
+      const results = senderAuth.signed_messages.map((m) => adapter.recoverAndVerify(m, source, perMessage));
+      return { results, recoveredAccount: source.account };
+    }
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/signer.js
+var require_signer = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/signer.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.localKeySigner = localKeySigner2;
+    var index_js_1 = require_adapters();
+    function localKeySigner2(network, privateKey) {
+      const adapter = (0, index_js_1.getChainAdapter)(network);
+      return {
+        async sign(signedMessage) {
+          const signature = await adapter.sign(signedMessage, privateKey);
+          const delegateSigner = adapter.deriveDelegateSigner?.(privateKey);
+          return delegateSigner !== void 0 ? { signature, delegateSigner } : { signature };
+        }
+      };
+    }
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/index.js
+var require_dist5 = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.localKeySigner = exports2.SignerMismatchError = exports2.RecoveryFailedError = exports2.MalformedPrehashError = exports2.verifyPaymentRequest = exports2.DESTINATION_COMMITMENT_WITNESS_VERSION = exports2.usesDestinationCommitment = exports2.MAX_DESTINATION_BYTES = exports2.deriveDepositRequestHash = exports2.buildEscrowDestination = exports2.getChainAdapter = void 0;
+    __exportStar(require_types(), exports2);
+    __exportStar(require_utils(), exports2);
+    __exportStar(require_chain_id2(), exports2);
+    var index_js_1 = require_adapters();
+    Object.defineProperty(exports2, "getChainAdapter", { enumerable: true, get: function() {
+      return index_js_1.getChainAdapter;
+    } });
+    var destination_js_1 = require_destination();
+    Object.defineProperty(exports2, "buildEscrowDestination", { enumerable: true, get: function() {
+      return destination_js_1.buildEscrowDestination;
+    } });
+    Object.defineProperty(exports2, "deriveDepositRequestHash", { enumerable: true, get: function() {
+      return destination_js_1.deriveDepositRequestHash;
+    } });
+    Object.defineProperty(exports2, "MAX_DESTINATION_BYTES", { enumerable: true, get: function() {
+      return destination_js_1.MAX_DESTINATION_BYTES;
+    } });
+    Object.defineProperty(exports2, "usesDestinationCommitment", { enumerable: true, get: function() {
+      return destination_js_1.usesDestinationCommitment;
+    } });
+    Object.defineProperty(exports2, "DESTINATION_COMMITMENT_WITNESS_VERSION", { enumerable: true, get: function() {
+      return destination_js_1.DESTINATION_COMMITMENT_WITNESS_VERSION;
+    } });
+    var verify_js_1 = require_verify();
+    Object.defineProperty(exports2, "verifyPaymentRequest", { enumerable: true, get: function() {
+      return verify_js_1.verifyPaymentRequest;
+    } });
+    var errors_js_1 = require_errors();
+    Object.defineProperty(exports2, "MalformedPrehashError", { enumerable: true, get: function() {
+      return errors_js_1.MalformedPrehashError;
+    } });
+    Object.defineProperty(exports2, "RecoveryFailedError", { enumerable: true, get: function() {
+      return errors_js_1.RecoveryFailedError;
+    } });
+    Object.defineProperty(exports2, "SignerMismatchError", { enumerable: true, get: function() {
+      return errors_js_1.SignerMismatchError;
+    } });
+    var signer_js_1 = require_signer();
+    Object.defineProperty(exports2, "localKeySigner", { enumerable: true, get: function() {
+      return signer_js_1.localKeySigner;
+    } });
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/allowance.js
+var require_allowance = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/allowance.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.UNLIMITED_APPROVAL_FLOOR = exports2.UNLIMITED_APPROVAL = void 0;
+    exports2.isAllowanceSufficient = isAllowanceSufficient;
+    exports2.effectiveRequirement = effectiveRequirement;
+    exports2.resolveApprovalAmount = resolveApprovalAmount;
+    var ethers_1 = require("ethers");
+    exports2.UNLIMITED_APPROVAL = ethers_1.MaxUint256;
+    exports2.UNLIMITED_APPROVAL_FLOOR = ethers_1.MaxUint256 / 2n;
+    function isAllowanceSufficient(current, requiredAllowance) {
+      return requiredAllowance !== void 0 ? current >= requiredAllowance : current >= exports2.UNLIMITED_APPROVAL_FLOOR;
+    }
+    function effectiveRequirement(requiredAllowance, approvalAmount) {
+      return requiredAllowance ?? approvalAmount;
+    }
+    function resolveApprovalAmount(approvalAmount, requiredAllowance) {
+      if (approvalAmount === void 0)
+        return exports2.UNLIMITED_APPROVAL;
+      if (approvalAmount <= 0n) {
+        throw new Error(`token_approval: approvalAmount must be positive, got ${approvalAmount}`);
+      }
+      if (requiredAllowance !== void 0 && approvalAmount < requiredAllowance) {
+        throw new Error(`token_approval: approvalAmount ${approvalAmount} is below requiredAllowance ${requiredAllowance}, so the approval would still fall short and every call would send another one`);
+      }
+      return approvalAmount;
+    }
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/adapters/unconfirmed.js
+var require_unconfirmed = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/adapters/unconfirmed.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.unconfirmed = unconfirmed;
+    exports2.isUnconfirmed = isUnconfirmed2;
+    function unconfirmed(message) {
+      return Object.assign(new Error(message), { unconfirmed: true });
+    }
+    function isUnconfirmed2(error) {
+      return error?.unconfirmed === true;
+    }
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/adapters/evm.js
+var require_evm2 = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/adapters/evm.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.evmAdapter = exports2.ERC20_ALLOWANCE_ABI = void 0;
+    var ethers_1 = require("ethers");
+    var evm_escrow_encoding_1 = require_dist3();
+    var unconfirmed_js_1 = require_unconfirmed();
+    exports2.ERC20_ALLOWANCE_ABI = [
+      "function allowance(address owner, address spender) view returns (uint256)",
+      "function approve(address spender, uint256 amount) returns (bool)"
+    ];
+    var DEFAULT_CONFIRMATION_TIMEOUT_MS = 6e4;
+    function requireSigner(params) {
+      if (!params.signer) {
+        throw new Error(`token_approval: approving on ${params.network} needs an ethers signer connected to that chain (params.signer)`);
+      }
+      return params.signer;
+    }
+    function erc20(params) {
+      return new ethers_1.Contract(params.token, exports2.ERC20_ALLOWANCE_ABI, requireSigner(params));
+    }
+    async function send(params, call, purpose) {
+      const tx = await call;
+      params.onSubmitted?.(tx.hash, purpose);
+      const timeoutMs = params.confirmation?.timeoutMs ?? DEFAULT_CONFIRMATION_TIMEOUT_MS;
+      try {
+        await tx.wait(1, timeoutMs);
+      } catch (error) {
+        if (isTimeout(error)) {
+          throw (0, unconfirmed_js_1.unconfirmed)(`token_approval: the ${purpose === "reset" ? "allowance reset" : "approval"} ${tx.hash} was not confirmed within ${timeoutMs}ms. It may still confirm \u2014 check the transaction before approving again.`);
+        }
+        throw error;
+      }
+      return tx.hash;
+    }
+    function isTimeout(error) {
+      return error?.code === "TIMEOUT";
+    }
+    exports2.evmAdapter = {
+      applicable: true,
+      resolveSpender(params) {
+        return params.spender ?? evm_escrow_encoding_1.PERMIT2_CONTRACT_ADDRESS;
+      },
+      async senderAddress(params) {
+        return await requireSigner(params).getAddress();
+      },
+      async readAllowance(params, spender) {
+        return await erc20(params).allowance(params.owner, spender);
+      },
+      async approve(params, spender, amount, current) {
+        const token = erc20(params);
+        if (current !== 0n && await refusesOverwrite(params, token, spender, amount)) {
+          const nonce = await requireSigner(params).getNonce("pending");
+          const resetTxHash = await send(params, token.approve(spender, 0n, { nonce }), "reset");
+          try {
+            return {
+              txHash: await send(params, token.approve(spender, amount, { nonce: nonce + 1 }), "approval"),
+              resetTxHash
+            };
+          } catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            if ((0, unconfirmed_js_1.isUnconfirmed)(error)) {
+              throw (0, unconfirmed_js_1.unconfirmed)(`token_approval: the allowance was reset to 0 in ${resetTxHash} and the new approval was broadcast but not confirmed (${detail}). If it lands the allowance is ${amount}; if it does not, it stays 0. Check that transaction before approving again.`);
+            }
+            throw new Error(`token_approval: the allowance was reset to 0 in ${resetTxHash}, but the new approval did not go through (${detail}). The allowance is currently 0 \u2014 re-run to finish.`);
+          }
+        }
+        return { txHash: await send(params, token.approve(spender, amount), "approval") };
+      }
+    };
+    async function refusesOverwrite(params, token, spender, amount) {
+      const data = token.interface.encodeFunctionData("approve", [spender, amount]);
+      try {
+        await requireSigner(params).call({ to: params.token, data });
+        return false;
+      } catch (error) {
+        if (isRevert(error))
+          return true;
+        throw error;
+      }
+    }
+    function isRevert(error) {
+      return error?.code === "CALL_EXCEPTION";
+    }
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/adapters/tron.js
+var require_tron2 = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/adapters/tron.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.tronAdapter = exports2.TRC20_ALLOWANCE_ABI = void 0;
+    var payment_request_sender_auth_1 = require_dist5();
+    var unconfirmed_js_1 = require_unconfirmed();
+    exports2.TRC20_ALLOWANCE_ABI = [
+      {
+        name: "allowance",
+        type: "function",
+        stateMutability: "View",
+        inputs: [
+          { name: "owner", type: "address" },
+          { name: "spender", type: "address" }
+        ],
+        outputs: [{ type: "uint256" }]
+      },
+      {
+        name: "approve",
+        type: "function",
+        stateMutability: "Nonpayable",
+        inputs: [
+          { name: "spender", type: "address" },
+          { name: "amount", type: "uint256" }
+        ],
+        outputs: [{ type: "bool" }]
+      }
+    ];
+    var DEFAULT_FEE_LIMIT = 1e8;
+    var DEFAULT_CONFIRMATION_TIMEOUT_MS = 6e4;
+    var DEFAULT_POLL_INTERVAL_MS2 = 1500;
+    function requireTronWeb(params) {
+      if (!params.tronWeb) {
+        throw new Error(`token_approval: approving on ${params.network} needs a TronWeb instance configured for that chain (params.tronWeb)`);
+      }
+      return params.tronWeb;
+    }
+    function token(params) {
+      return requireTronWeb(params).contract(exports2.TRC20_ALLOWANCE_ABI, params.token);
+    }
+    var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+    async function waitForConfirmation(tronWeb, txId, options) {
+      const timeoutMs = options?.timeoutMs ?? DEFAULT_CONFIRMATION_TIMEOUT_MS;
+      const pollIntervalMs = options?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS2;
+      const deadline = Date.now() + timeoutMs;
+      for (; ; ) {
+        let result;
+        try {
+          result = (await tronWeb.trx.getTransactionInfo(txId))?.receipt?.result;
+        } catch {
+        }
+        if (result === "SUCCESS")
+          return;
+        if (result !== void 0) {
+          throw new Error(`token_approval: Tron approval ${txId} failed on-chain (${result})`);
+        }
+        if (Date.now() >= deadline) {
+          throw (0, unconfirmed_js_1.unconfirmed)(`token_approval: Tron approval ${txId} was not confirmed within ${timeoutMs}ms. It may still confirm \u2014 check the transaction before approving again.`);
+        }
+        await sleep(pollIntervalMs);
+      }
+    }
+    async function send(params, contract, spender, amount, purpose) {
+      const txId = await contract.approve(spender, amount.toString()).send({ feeLimit: params.confirmation?.feeLimit ?? DEFAULT_FEE_LIMIT });
+      params.onSubmitted?.(txId, purpose);
+      await waitForConfirmation(requireTronWeb(params), txId, params.confirmation);
+      return txId;
+    }
+    exports2.tronAdapter = {
+      applicable: true,
+      resolveSpender(params) {
+        return params.spender ?? (0, payment_request_sender_auth_1.resolveTronPermit2)(params.network);
+      },
+      async senderAddress(params) {
+        return requireTronWeb(params).defaultAddress?.base58 || void 0;
+      },
+      async readAllowance(params, spender) {
+        const raw = await token(params).allowance(params.owner, spender).call();
+        return BigInt(String(raw));
+      },
+      async approve(params, spender, amount, current) {
+        const contract = token(params);
+        try {
+          return { txHash: await send(params, contract, spender, amount, "approval") };
+        } catch (error) {
+          if (current === 0n || (0, unconfirmed_js_1.isUnconfirmed)(error))
+            throw error;
+          throw new Error(`token_approval: the approval on ${params.network} failed while an allowance of ${current} was already set (${error instanceof Error ? error.message : String(error)}). Some tokens refuse to replace a non-zero allowance in place: approve 0 first, then retry.`);
+        }
+      }
+    };
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/adapters/solana.js
+var require_solana2 = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/adapters/solana.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.solanaAdapter = void 0;
+    exports2.solanaAdapter = {
+      applicable: false,
+      resolveSpender() {
+        throw new Error("token_approval: Solana does not use a Permit2-style allowance");
+      },
+      async senderAddress() {
+        throw new Error("token_approval: Solana does not use a Permit2-style allowance");
+      },
+      async readAllowance() {
+        throw new Error("token_approval: Solana does not use a Permit2-style allowance");
+      },
+      async approve() {
+        throw new Error("token_approval: Solana does not use a Permit2-style allowance");
+      }
+    };
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/adapters/index.js
+var require_adapters2 = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/adapters/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getChainAdapter = getChainAdapter2;
-    var chain_id_js_1 = require_chain_id2();
-    var evm_js_1 = require_evm();
-    var tron_js_1 = require_tron();
-    var solana_js_1 = require_solana();
-    var adapters2 = {
+    exports2.approvalAdapterFor = approvalAdapterFor;
+    var payment_request_sender_auth_1 = require_dist5();
+    var evm_js_1 = require_evm2();
+    var tron_js_1 = require_tron2();
+    var solana_js_1 = require_solana2();
+    var ADAPTERS = {
       eip155: evm_js_1.evmAdapter,
       tron: tron_js_1.tronAdapter,
       solana: solana_js_1.solanaAdapter
     };
-    function getChainAdapter2(caip2) {
-      const adapter = adapters2[(0, chain_id_js_1.namespaceOf)(caip2)];
+    function approvalAdapterFor(network) {
+      const namespace = (0, payment_request_sender_auth_1.namespaceOf)(network);
+      const adapter = Object.hasOwn(ADAPTERS, namespace) ? ADAPTERS[namespace] : void 0;
       if (!adapter) {
-        throw new Error(`sender_auth: unsupported source chain '${caip2}'`);
+        throw new Error(`token_approval: no approval adapter for network '${network}'`);
       }
       return adapter;
     }
   }
 });
 
-// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/verify.js
-var require_verify = __commonJS({
-  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/verify.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.verifyPaymentRequest = verifyPaymentRequest;
-    var index_js_1 = require_adapters();
-    function parseSourceAsset(assetIdentifier) {
-      const parts = assetIdentifier.split("/");
-      const nsParts = parts[1]?.split(":");
-      if (parts.length < 2 || !nsParts || nsParts.length < 2 || !nsParts[1]) {
-        throw new Error(`sender_auth: invalid source asset "${assetIdentifier}"`);
-      }
-      return { network: parts[0], asset: nsParts[1] };
-    }
-    function verifyPaymentRequest(request2, expected = {}) {
-      const senderAuth = request2.sender_auth;
-      if (!senderAuth?.signed_messages?.length) {
-        throw new Error("sender_auth: request has no signed_messages to verify");
-      }
-      if (!request2.source) {
-        throw new Error("sender_auth: request has no source");
-      }
-      const requestSource = parseSourceAsset(request2.source.asset_identifier);
-      const { sourceAsset, network: networkOverride, maxSourceAmount: amountOverride, ...scheme } = expected;
-      const network = networkOverride ?? requestSource.network;
-      const asset = sourceAsset ?? requestSource.asset;
-      const maxSourceAmount = amountOverride ?? request2.max_source_amount ?? "0";
-      const source = { network, asset, account: request2.source.account };
-      const perMessage = { ...scheme, maxSourceAmount };
-      const adapter = (0, index_js_1.getChainAdapter)(network);
-      const results = senderAuth.signed_messages.map((m) => adapter.recoverAndVerify(m, source, perMessage));
-      return { results, recoveredAccount: source.account };
-    }
-  }
-});
-
-// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/signer.js
-var require_signer = __commonJS({
-  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/signer.js"(exports2) {
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/sender.js
+var require_sender = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/sender.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.localKeySigner = localKeySigner2;
-    var index_js_1 = require_adapters();
-    function localKeySigner2(network, privateKey) {
-      const adapter = (0, index_js_1.getChainAdapter)(network);
-      return {
-        async sign(signedMessage) {
-          const signature = await adapter.sign(signedMessage, privateKey);
-          const delegateSigner = adapter.deriveDelegateSigner?.(privateKey);
-          return delegateSigner !== void 0 ? { signature, delegateSigner } : { signature };
-        }
-      };
+    exports2.assertSenderIsOwner = assertSenderIsOwner;
+    function assertSenderIsOwner(owner, sender) {
+      if (sender === void 0 || sender.toLowerCase() === owner.toLowerCase())
+        return;
+      throw new Error(`token_approval: the approval would be sent by ${sender}, but the allowance is being granted for ${owner}. An approval only ever applies to the account that sends it, so this would approve ${sender} and leave ${owner} unable to pay. Pass a signer for ${owner}, or read the allowance for ${sender}.`);
     }
   }
 });
 
-// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/index.js
-var require_dist4 = __commonJS({
-  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/index.js"(exports2) {
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/index.js
+var require_dist6 = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/token-approval/dist/index.js"(exports2) {
     "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    }) : (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    }));
-    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
-      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
-    };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.localKeySigner = exports2.SignerMismatchError = exports2.RecoveryFailedError = exports2.MalformedPrehashError = exports2.verifyPaymentRequest = exports2.getChainAdapter = void 0;
-    __exportStar(require_types(), exports2);
-    __exportStar(require_utils(), exports2);
-    __exportStar(require_chain_id2(), exports2);
-    var index_js_1 = require_adapters();
-    Object.defineProperty(exports2, "getChainAdapter", { enumerable: true, get: function() {
-      return index_js_1.getChainAdapter;
+    exports2.approvalAdapterFor = exports2.isUnconfirmed = exports2.assertSenderIsOwner = exports2.resolveApprovalAmount = exports2.isAllowanceSufficient = exports2.effectiveRequirement = exports2.UNLIMITED_APPROVAL_FLOOR = exports2.UNLIMITED_APPROVAL = void 0;
+    exports2.needsSourceApproval = needsSourceApproval2;
+    exports2.ensureSourceApproval = ensureSourceApproval2;
+    var allowance_js_1 = require_allowance();
+    var index_js_1 = require_adapters2();
+    var sender_js_1 = require_sender();
+    var allowance_js_2 = require_allowance();
+    Object.defineProperty(exports2, "UNLIMITED_APPROVAL", { enumerable: true, get: function() {
+      return allowance_js_2.UNLIMITED_APPROVAL;
     } });
-    var verify_js_1 = require_verify();
-    Object.defineProperty(exports2, "verifyPaymentRequest", { enumerable: true, get: function() {
-      return verify_js_1.verifyPaymentRequest;
+    Object.defineProperty(exports2, "UNLIMITED_APPROVAL_FLOOR", { enumerable: true, get: function() {
+      return allowance_js_2.UNLIMITED_APPROVAL_FLOOR;
     } });
-    var errors_js_1 = require_errors();
-    Object.defineProperty(exports2, "MalformedPrehashError", { enumerable: true, get: function() {
-      return errors_js_1.MalformedPrehashError;
+    Object.defineProperty(exports2, "effectiveRequirement", { enumerable: true, get: function() {
+      return allowance_js_2.effectiveRequirement;
     } });
-    Object.defineProperty(exports2, "RecoveryFailedError", { enumerable: true, get: function() {
-      return errors_js_1.RecoveryFailedError;
+    Object.defineProperty(exports2, "isAllowanceSufficient", { enumerable: true, get: function() {
+      return allowance_js_2.isAllowanceSufficient;
     } });
-    Object.defineProperty(exports2, "SignerMismatchError", { enumerable: true, get: function() {
-      return errors_js_1.SignerMismatchError;
+    Object.defineProperty(exports2, "resolveApprovalAmount", { enumerable: true, get: function() {
+      return allowance_js_2.resolveApprovalAmount;
     } });
-    var signer_js_1 = require_signer();
-    Object.defineProperty(exports2, "localKeySigner", { enumerable: true, get: function() {
-      return signer_js_1.localKeySigner;
+    var sender_js_2 = require_sender();
+    Object.defineProperty(exports2, "assertSenderIsOwner", { enumerable: true, get: function() {
+      return sender_js_2.assertSenderIsOwner;
+    } });
+    var unconfirmed_js_1 = require_unconfirmed();
+    Object.defineProperty(exports2, "isUnconfirmed", { enumerable: true, get: function() {
+      return unconfirmed_js_1.isUnconfirmed;
     } });
+    var index_js_2 = require_adapters2();
+    Object.defineProperty(exports2, "approvalAdapterFor", { enumerable: true, get: function() {
+      return index_js_2.approvalAdapterFor;
+    } });
+    async function needsSourceApproval2(params) {
+      const adapter = (0, index_js_1.approvalAdapterFor)(params.network);
+      if (!adapter.applicable)
+        return false;
+      const required = (0, allowance_js_1.effectiveRequirement)(params.requiredAllowance, params.approvalAmount);
+      (0, allowance_js_1.resolveApprovalAmount)(params.approvalAmount, required);
+      const spender = adapter.resolveSpender(params);
+      const current = await adapter.readAllowance(params, spender);
+      return !(0, allowance_js_1.isAllowanceSufficient)(current, required);
+    }
+    async function ensureSourceApproval2(params) {
+      const adapter = (0, index_js_1.approvalAdapterFor)(params.network);
+      if (!adapter.applicable)
+        return { alreadySufficient: true };
+      const required = (0, allowance_js_1.effectiveRequirement)(params.requiredAllowance, params.approvalAmount);
+      const amount = (0, allowance_js_1.resolveApprovalAmount)(params.approvalAmount, required);
+      const spender = adapter.resolveSpender(params);
+      const current = await adapter.readAllowance(params, spender);
+      if ((0, allowance_js_1.isAllowanceSufficient)(current, required)) {
+        return { alreadySufficient: true };
+      }
+      (0, sender_js_1.assertSenderIsOwner)(params.owner, await adapter.senderAddress(params));
+      return { alreadySufficient: false, ...await adapter.approve(params, spender, amount, current) };
+    }
+  }
+});
+
+// src/signers/pinned-address.ts
+function requirePinnedSender(pinnedAddress) {
+  if (pinnedAddress === null || pinnedAddress === void 0) return void 0;
+  if (typeof pinnedAddress !== "string" || pinnedAddress.trim() === "") {
+    throw new Error(
+      "The sender address (pinnedAddress) must be a non-empty address. Pass the sender to check it against the signing wallet or key. SDK callers may omit pinnedAddress to skip that check."
+    );
+  }
+  return pinnedAddress;
+}
+var init_pinned_address = __esm({
+  "src/signers/pinned-address.ts"() {
+    "use strict";
   }
 });
 
@@ -2536,7 +4106,7 @@ var require_policy = __commonJS({
 });
 
 // ../key-management/common/typescript/dist/index.js
-var require_dist5 = __commonJS({
+var require_dist7 = __commonJS({
   "../key-management/common/typescript/dist/index.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
@@ -2678,7 +4248,7 @@ var require_client = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.TurnkeyClient = void 0;
     var promises_1 = require("timers/promises");
-    var km_core_1 = require_dist5();
+    var km_core_1 = require_dist7();
     var constants_1 = require_constants();
     var logger_1 = require_logger();
     var meter_1 = require_meter();
@@ -2693,6 +4263,7 @@ var require_client = __commonJS({
       retryCounter;
       backoffHistogram;
       activityPendingCounter;
+      signDurationHistogram;
       // The private API scalar is held only long enough to construct the stamper. After
       // `getStamper()` runs, this is nulled out so the hex string doesn't survive on the heap
       // for the client's lifetime. Web Crypto holds the imported key as an opaque CryptoKey.
@@ -2721,6 +4292,10 @@ var require_client = __commonJS({
         this.activityPendingCounter = meter.createCounter("turnkey.activity_pending_total", {
           description: "Activities that entered async polling (did not complete synchronously in the submit response), labeled by activity type"
         });
+        this.signDurationHistogram = meter.createHistogram("turnkey.sign_duration_ms", {
+          description: "Full Turnkey activity round-trip latency (concurrency-semaphore wait + submit + poll), labeled by activity type and outcome (success|error)",
+          unit: "ms"
+        });
       }
       emitRetry(reason, path) {
         try {
@@ -2740,6 +4315,12 @@ var require_client = __commonJS({
         } catch {
         }
       }
+      emitSignDuration(durationMs, activityType, outcome) {
+        try {
+          this.signDurationHistogram.record(durationMs, { activity_type: activityType, outcome });
+        } catch {
+        }
+      }
       // ── public surface ─────────────────────────────────────────────────────────
       /** Boot-time reachability + auth probe. Throws TURNKEY_AUTH on bad credentials. */
       async whoami() {
@@ -2789,39 +4370,47 @@ var require_client = __commonJS({
       }
       // ── activity submission ────────────────────────────────────────────────────
       async submitActivity(activityType, endpoint, parameters) {
-        const body = {
-          type: activityType,
-          timestampMs: String(Date.now()),
-          organizationId: this.opts.organizationId,
-          parameters
-        };
-        const signWith = typeof parameters.signWith === "string" ? parameters.signWith : void 0;
-        const ctx = `activity=${activityType}${signWith ? ` signWith=${signWith}` : ""}`;
-        const resp = await this.queryPost(`/public/v1/submit/${endpoint}`, body);
-        let activity = resp.activity;
-        const deadline = Date.now() + POLL_TIMEOUT_MS;
-        let pollAttempt = 0;
-        if (activity?.status === "ACTIVITY_STATUS_PENDING") {
-          this.emitActivityPending(activityType);
-        }
-        while (activity?.status === "ACTIVITY_STATUS_PENDING") {
-          if (Date.now() > deadline) {
-            throw (0, km_core_1.signerRetryable)(km_core_1.SignerErrorCode.TURNKEY_SIGNER_UNAVAILABLE, `Turnkey ${ctx} activityId=${activity.id} stayed PENDING past ${POLL_TIMEOUT_MS}ms`);
+        const start = Date.now();
+        let outcome = "error";
+        try {
+          const body = {
+            type: activityType,
+            timestampMs: String(Date.now()),
+            organizationId: this.opts.organizationId,
+            parameters
+          };
+          const signWith = typeof parameters.signWith === "string" ? parameters.signWith : void 0;
+          const ctx = `activity=${activityType}${signWith ? ` signWith=${signWith}` : ""}`;
+          const resp = await this.queryPost(`/public/v1/submit/${endpoint}`, body);
+          let activity = resp.activity;
+          const deadline = Date.now() + POLL_TIMEOUT_MS;
+          let pollAttempt = 0;
+          if (activity?.status === "ACTIVITY_STATUS_PENDING") {
+            this.emitActivityPending(activityType);
           }
-          const sleepIdx = Math.min(pollAttempt, POLL_BACKOFF_MS.length - 1);
-          await (0, promises_1.setTimeout)(POLL_BACKOFF_MS[sleepIdx]);
-          pollAttempt++;
-          const polled = await this.queryPost("/public/v1/query/get_activity", { organizationId: this.opts.organizationId, activityId: activity.id });
-          activity = polled.activity;
-        }
-        if (activity?.status !== "ACTIVITY_STATUS_COMPLETED") {
-          const failure = activity?.failure ?? {};
-          throw (0, km_core_1.signerTerminal)(km_core_1.SignerErrorCode.TURNKEY_ACTIVITY_FAILED, `Turnkey ${ctx} activityId=${activity?.id ?? "?"} status=${activity?.status ?? "unknown"}; ${JSON.stringify(failure)}`);
-        }
-        if (activity.result == null) {
-          throw (0, km_core_1.signerTerminal)(km_core_1.SignerErrorCode.TURNKEY_BAD_RESPONSE, `Turnkey ${ctx} activityId=${activity.id} COMPLETED but result was missing`);
+          while (activity?.status === "ACTIVITY_STATUS_PENDING") {
+            if (Date.now() > deadline) {
+              throw (0, km_core_1.signerRetryable)(km_core_1.SignerErrorCode.TURNKEY_SIGNER_UNAVAILABLE, `Turnkey ${ctx} activityId=${activity.id} stayed PENDING past ${POLL_TIMEOUT_MS}ms`);
+            }
+            const sleepIdx = Math.min(pollAttempt, POLL_BACKOFF_MS.length - 1);
+            await (0, promises_1.setTimeout)(POLL_BACKOFF_MS[sleepIdx]);
+            pollAttempt++;
+            const polled = await this.queryPost("/public/v1/query/get_activity", { organizationId: this.opts.organizationId, activityId: activity.id });
+            activity = polled.activity;
+          }
+          if (activity?.status !== "ACTIVITY_STATUS_COMPLETED") {
+            const failure = activity?.failure ?? {};
+            const fp = activity?.fingerprint ? ` fingerprint=${activity.fingerprint}` : "";
+            throw (0, km_core_1.signerTerminal)(km_core_1.SignerErrorCode.TURNKEY_ACTIVITY_FAILED, `Turnkey ${ctx} activityId=${activity?.id ?? "?"} status=${activity?.status ?? "unknown"}${fp}; ${JSON.stringify(failure)}`);
+          }
+          if (activity.result == null) {
+            throw (0, km_core_1.signerTerminal)(km_core_1.SignerErrorCode.TURNKEY_BAD_RESPONSE, `Turnkey ${ctx} activityId=${activity.id} COMPLETED but result was missing`);
+          }
+          outcome = "success";
+          return activity.result;
+        } finally {
+          this.emitSignDuration(Date.now() - start, activityType, outcome);
         }
-        return activity.result;
       }
       // ── HTTP layer ────────────────────────────────────────────────────────────
       /**
@@ -3039,7 +4628,7 @@ var require_signer_base = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.resolveTurnkeyAccountAddress = resolveTurnkeyAccountAddress;
     var promises_1 = require("timers/promises");
-    var km_core_1 = require_dist5();
+    var km_core_1 = require_dist7();
     var constants_1 = require_constants();
     var DISCOVERY_BACKOFF_MS = constants_1.TURNKEY_RETRY_BACKOFF_MS;
     async function resolveTurnkeyAccountAddress(deps, addressFormat) {
@@ -3095,17 +4684,33 @@ var require_secp256k1_helpers = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.signSecp256k1PreimageAndVerify = signSecp256k1PreimageAndVerify;
+    exports2.signSecp256k1TypedDataAndVerify = signSecp256k1TypedDataAndVerify;
     exports2.bytesFromHexOrBytes = bytesFromHexOrBytes;
     var ethers_1 = require("ethers");
-    var km_core_1 = require_dist5();
+    var km_core_1 = require_dist7();
+    var EIP712_HASH_FUNCTION = "HASH_FUNCTION_NOT_APPLICABLE";
     async function signSecp256k1PreimageAndVerify(client, signWith, preimage, expectedEvmAddrLower) {
       const preimageHex = (0, ethers_1.hexlify)(preimage).slice(2);
-      const { r, s, v } = await client.signRawPayload({
+      const parts = await client.signRawPayload({
         signWith,
         payload: preimageHex,
         encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
         hashFunction: "HASH_FUNCTION_KECCAK256"
       });
+      return recoverAndVerify(parts, (0, ethers_1.keccak256)(preimage), expectedEvmAddrLower);
+    }
+    async function signSecp256k1TypedDataAndVerify(client, signWith, domain, types, message, expectedEvmAddrLower) {
+      const payload = ethers_1.TypedDataEncoder.getPayload(domain, types, message);
+      const parts = await client.signRawPayload({
+        signWith,
+        payload: JSON.stringify(payload),
+        encoding: "PAYLOAD_ENCODING_EIP712",
+        hashFunction: EIP712_HASH_FUNCTION
+      });
+      const digestHex = ethers_1.TypedDataEncoder.hash(domain, types, message);
+      return recoverAndVerify(parts, digestHex, expectedEvmAddrLower);
+    }
+    function recoverAndVerify({ r, s, v }, digestHex, expectedEvmAddrLower) {
       let sig;
       try {
         sig = ethers_1.Signature.from({
@@ -3116,7 +4721,6 @@ var require_secp256k1_helpers = __commonJS({
       } catch (err) {
         throw (0, km_core_1.signerTerminal)(km_core_1.SignerErrorCode.TURNKEY_BAD_RESPONSE, `Turnkey returned malformed secp256k1 signature parts r=${r} s=${s} v=${v}`, err instanceof Error ? err : void 0);
       }
-      const digestHex = (0, ethers_1.keccak256)(preimage);
       const recovered = (0, ethers_1.recoverAddress)(digestHex, sig).toLowerCase();
       if (recovered !== expectedEvmAddrLower) {
         throw (0, km_core_1.signerTerminal)(km_core_1.SignerErrorCode.TURNKEY_BAD_RESPONSE, `secp256k1 sign-then-recover mismatch: recovered ${recovered}, expected ${expectedEvmAddrLower}`);
@@ -3130,13 +4734,13 @@ var require_secp256k1_helpers = __commonJS({
 });
 
 // ../key-management/providers/turnkey/typescript/dist/chains/evm.js
-var require_evm2 = __commonJS({
+var require_evm3 = __commonJS({
   "../key-management/providers/turnkey/typescript/dist/chains/evm.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.TurnkeyEvmSigner = void 0;
     var ethers_1 = require("ethers");
-    var km_core_1 = require_dist5();
+    var km_core_1 = require_dist7();
     var signer_base_1 = require_signer_base();
     var secp256k1_helpers_1 = require_secp256k1_helpers();
     var ADDRESS_FORMAT = "ADDRESS_FORMAT_ETHEREUM";
@@ -3180,8 +4784,7 @@ ${msgBytes.length}`);
       }
       async signTypedData(domain, types, message) {
         const { signWith, lower } = this.requireAddresses();
-        const preimage = (0, ethers_1.getBytes)(ethers_1.TypedDataEncoder.encode(domain, types, message));
-        return (0, secp256k1_helpers_1.signSecp256k1PreimageAndVerify)(this.client, signWith, preimage, lower);
+        return (0, secp256k1_helpers_1.signSecp256k1TypedDataAndVerify)(this.client, signWith, domain, types, message, lower);
       }
       async signTransaction(tx) {
         const { signWith, lower } = this.requireAddresses();
@@ -3253,7 +4856,7 @@ ${msgBytes.length}`);
 });
 
 // ../key-management/providers/turnkey/typescript/dist/chains/solana.js
-var require_solana2 = __commonJS({
+var require_solana3 = __commonJS({
   "../key-management/providers/turnkey/typescript/dist/chains/solana.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
@@ -3298,9 +4901,10 @@ var require_solana2 = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.TurnkeySolanaSigner = void 0;
+    exports2.encodePayload = encodePayload;
     var web3_js_1 = require("@solana/web3.js");
     var bs58_1 = __importDefault(require("bs58"));
-    var km_core_1 = require_dist5();
+    var km_core_1 = require_dist7();
     var signer_base_1 = require_signer_base();
     var ADDRESS_FORMAT = "ADDRESS_FORMAT_SOLANA";
     var TurnkeySolanaSigner2 = class {
@@ -3331,8 +4935,7 @@ var require_solana2 = __commonJS({
         }
         const { r, s } = await this.client.signRawPayload({
           signWith: this.address,
-          payload: Buffer.from(bytes).toString("hex"),
-          encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
+          ...encodePayload(bytes),
           hashFunction: "HASH_FUNCTION_NOT_APPLICABLE"
         });
         const sig = Buffer.concat([Buffer.from(stripHex(r), "hex"), Buffer.from(stripHex(s), "hex")]);
@@ -3373,6 +4976,15 @@ var require_solana2 = __commonJS({
       }
     };
     exports2.TurnkeySolanaSigner = TurnkeySolanaSigner2;
+    function encodePayload(bytes) {
+      const buf = Buffer.from(bytes);
+      const text = buf.toString("utf8");
+      const textual = buf.every((b) => b >= 32 && b <= 126 || b === 9 || b === 10 || b === 13);
+      if (textual && Buffer.from(text, "utf8").equals(buf)) {
+        return { payload: text, encoding: "PAYLOAD_ENCODING_TEXT_UTF8" };
+      }
+      return { payload: buf.toString("hex"), encoding: "PAYLOAD_ENCODING_HEXADECIMAL" };
+    }
     function stripHex(s) {
       return s.startsWith("0x") ? s.slice(2) : s;
     }
@@ -3385,7 +4997,7 @@ var require_solana2 = __commonJS({
 });
 
 // ../key-management/providers/turnkey/typescript/dist/chains/tron.js
-var require_tron2 = __commonJS({
+var require_tron3 = __commonJS({
   "../key-management/providers/turnkey/typescript/dist/chains/tron.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
@@ -3397,7 +5009,7 @@ var require_tron2 = __commonJS({
     var bs58_1 = __importDefault(require("bs58"));
     var ethers_1 = require("ethers");
     var node_crypto_1 = require("crypto");
-    var km_core_1 = require_dist5();
+    var km_core_1 = require_dist7();
     var signer_base_1 = require_signer_base();
     var secp256k1_helpers_1 = require_secp256k1_helpers();
     var ADDRESS_FORMAT = "ADDRESS_FORMAT_TRON";
@@ -3440,8 +5052,7 @@ ${messageBytes.length}`);
       }
       async signTypedData(domain, types, message) {
         const { address, evmAddr } = this.requireReady();
-        const preimage = (0, ethers_1.getBytes)(ethers_1.TypedDataEncoder.encode(domain, types, message));
-        return (0, secp256k1_helpers_1.signSecp256k1PreimageAndVerify)(this.client, address, preimage, evmAddr);
+        return (0, secp256k1_helpers_1.signSecp256k1TypedDataAndVerify)(this.client, address, domain, types, message, evmAddr);
       }
       async signTransaction(tx) {
         const { address, evmAddr } = this.requireReady();
@@ -3620,6 +5231,200 @@ var require_users = __commonJS({
   }
 });
 
+// ../key-management/providers/turnkey/typescript/dist/admin/activities.js
+var require_activities = __commonJS({
+  "../key-management/providers/turnkey/typescript/dist/admin/activities.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getRootQuorum = getRootQuorum;
+    exports2.getActivity = getActivity;
+    exports2.listPendingActivities = listPendingActivities;
+    exports2.approvedVoterIds = approvedVoterIds;
+    exports2.approveActivity = approveActivity;
+    async function getRootQuorum(client, organizationId) {
+      const r = await client.query("/public/v1/query/get_organization", { organizationId });
+      const q = r.organizationData?.rootQuorum;
+      if (typeof q?.threshold !== "number") {
+        throw new Error(`get_organization on ${organizationId} returned no rootQuorum.threshold: ${JSON.stringify(r).slice(0, 200)}`);
+      }
+      return { threshold: q.threshold, userIds: q.userIds ?? [] };
+    }
+    async function getActivity(client, organizationId, activityId) {
+      const r = await client.query("/public/v1/query/get_activity", {
+        organizationId,
+        activityId
+      });
+      if (!r.activity?.id) {
+        throw new Error(`get_activity returned no activity for ${activityId} in ${organizationId}`);
+      }
+      return r.activity;
+    }
+    async function listPendingActivities(client, organizationId) {
+      const r = await client.query("/public/v1/query/list_activities", { organizationId, filterByStatus: ["ACTIVITY_STATUS_CONSENSUS_NEEDED"] });
+      return r.activities ?? [];
+    }
+    function approvedVoterIds(activity) {
+      const ids = (activity.votes ?? []).filter((v) => v.selection === "VOTE_SELECTION_APPROVED").map((v) => v.userId).filter((id) => Boolean(id));
+      return new Set(ids);
+    }
+    async function approveActivity(client, organizationId, fingerprint) {
+      const r = await client.query("/public/v1/submit/approve_activity", {
+        type: "ACTIVITY_TYPE_APPROVE_ACTIVITY",
+        timestampMs: String(Date.now()),
+        organizationId,
+        parameters: { fingerprint }
+      });
+      if (!r.activity) {
+        throw new Error(`approve_activity returned no activity for ${fingerprint}`);
+      }
+      return r.activity;
+    }
+  }
+});
+
+// ../key-management/providers/turnkey/typescript/dist/admin/api-keys.js
+var require_api_keys = __commonJS({
+  "../key-management/providers/turnkey/typescript/dist/admin/api-keys.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.UnsafeRevocationError = exports2.MAX_API_KEYS_PER_USER = void 0;
+    exports2.getUser = getUser;
+    exports2.listUsers = listUsers;
+    exports2.addApiKeys = addApiKeys;
+    exports2.deleteApiKeys = deleteApiKeys;
+    exports2.isDurableApiKey = isDurableApiKey;
+    exports2.isExpiredApiKey = isExpiredApiKey;
+    exports2.planRevocation = planRevocation;
+    exports2.findApiKeyByPublicKey = findApiKeyByPublicKey;
+    exports2.MAX_API_KEYS_PER_USER = 10;
+    async function getUser(client, organizationId, userId) {
+      const r = await client.query("/public/v1/query/get_user", {
+        organizationId,
+        userId
+      });
+      if (!r.user?.userId) {
+        throw new Error(`get_user returned no user for ${userId} in ${organizationId}`);
+      }
+      return normalizeUser(r.user);
+    }
+    async function listUsers(client, organizationId) {
+      const r = await client.query("/public/v1/query/list_users", {
+        organizationId
+      });
+      return (r.users ?? []).map(normalizeUser);
+    }
+    async function addApiKeys(client, input) {
+      if (input.apiKeys.length === 0)
+        throw new Error("addApiKeys called with no keys");
+      const result = await client.executeActivity("ACTIVITY_TYPE_CREATE_API_KEYS_V2", "create_api_keys", {
+        userId: input.userId,
+        apiKeys: input.apiKeys.map((k) => ({
+          apiKeyName: k.apiKeyName,
+          publicKey: k.publicKey,
+          curveType: k.curveType ?? "API_KEY_CURVE_P256",
+          ...k.expirationSeconds ? { expirationSeconds: k.expirationSeconds } : {}
+        }))
+      });
+      const ids = result.createApiKeysResult?.apiKeyIds;
+      if (!ids?.length) {
+        throw new Error(`CREATE_API_KEYS_V2 returned no apiKeyIds for user ${input.userId}: ${JSON.stringify(result)}`);
+      }
+      return ids;
+    }
+    async function deleteApiKeys(client, input) {
+      if (input.apiKeyIds.length === 0)
+        throw new Error("deleteApiKeys called with no apiKeyIds");
+      const result = await client.executeActivity("ACTIVITY_TYPE_DELETE_API_KEYS", "delete_api_keys", { userId: input.userId, apiKeyIds: [...input.apiKeyIds] });
+      return result.deleteApiKeysResult?.apiKeyIds ?? [];
+    }
+    function isDurableApiKey(key) {
+      return !key.expirationSeconds;
+    }
+    function isExpiredApiKey(key, nowSeconds) {
+      if (!key.expirationSeconds)
+        return false;
+      const created = Number(key.createdAt?.seconds);
+      const ttl = Number(key.expirationSeconds);
+      if (!Number.isFinite(created) || !Number.isFinite(ttl))
+        return false;
+      return created + ttl <= nowSeconds;
+    }
+    var UnsafeRevocationError = class extends Error {
+      code;
+      constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "UnsafeRevocationError";
+      }
+    };
+    exports2.UnsafeRevocationError = UnsafeRevocationError;
+    function planRevocation(input) {
+      const { user, nowSeconds } = input;
+      const stampingPub = input.stampingPublicKey.toLowerCase();
+      const verifyPub = input.verifyPublicKey?.toLowerCase();
+      const explicitIds = input.explicitIds;
+      if (explicitIds.length === 0) {
+        throw new UnsafeRevocationError("NO_KEY_ID", `No key ids given. Name every key to revoke from "${user.userName}" explicitly, so which key dies never depends on which credential is in the environment.`);
+      }
+      const byId = new Map(user.apiKeys.map((k) => [k.apiKeyId, k]));
+      const unknown = explicitIds.filter((id) => !byId.has(id));
+      if (unknown.length > 0) {
+        throw new UnsafeRevocationError("UNKNOWN_KEY_ID", `--key-id names keys that are not on user "${user.userName}": ${unknown.join(", ")}. They may belong to another user, or already be revoked.`);
+      }
+      const targets = [...new Set(explicitIds)].map((id) => byId.get(id));
+      const revokedIds = new Set(targets.map((k) => k.apiKeyId));
+      const survivors = user.apiKeys.filter((k) => !revokedIds.has(k.apiKeyId));
+      const live = survivors.filter((k) => !isExpiredApiKey(k, nowSeconds));
+      const durableSurvivors = live.filter(isDurableApiKey);
+      const hasPasskey = user.authenticators.length > 0;
+      const stampingKey = user.apiKeys.find((k) => k.credential?.publicKey?.toLowerCase() === stampingPub);
+      if (input.selfRotation && !stampingKey) {
+        throw new UnsafeRevocationError("STAMPING_KEY_NOT_ON_USER", `The public key stamping this request is not among "${user.userName}"'s registered keys, yet Turnkey resolved it to that user. Nothing that protects the surviving key can be trusted in that state. Re-check the credential env vars before revoking anything.`);
+      }
+      const suicidal = targets.find((k) => k.credential?.publicKey?.toLowerCase() === stampingPub);
+      if (suicidal) {
+        throw new UnsafeRevocationError("DELETES_AUTHORIZING_KEY", `${suicidal.apiKeyId} ("${suicidal.apiKeyName}") is the key stamping this request. Stamp with the key that should survive, or name the old key with --key-id.`);
+      }
+      if (verifyPub) {
+        const survivor = user.apiKeys.find((k) => k.credential?.publicKey?.toLowerCase() === verifyPub);
+        if (!survivor) {
+          throw new UnsafeRevocationError("SURVIVOR_NOT_REGISTERED", `--verify-public-key is not registered on "${user.userName}". Run --add first, or check you pasted the public key of the right user.`);
+        }
+        if (revokedIds.has(survivor.apiKeyId)) {
+          throw new UnsafeRevocationError("SURVIVOR_IN_REVOKE_SET", `--verify-public-key resolves to ${survivor.apiKeyId} ("${survivor.apiKeyName}"), which is in the revoke set. That would delete the key you just deployed.`);
+        }
+      }
+      const stampedAt = Number(stampingKey?.createdAt?.seconds);
+      if (!input.force && Number.isFinite(stampedAt)) {
+        const newer = targets.filter((k) => {
+          const created = Number(k.createdAt?.seconds);
+          return Number.isFinite(created) && created > stampedAt;
+        });
+        if (newer.length > 0) {
+          const list = newer.map((k) => `${k.apiKeyId} ("${k.apiKeyName}")`).join(", ");
+          throw new UnsafeRevocationError("DELETES_NEWER_KEY", `${list} was created AFTER the key stamping this request, so this would delete the replacement and keep the key being replaced. Stamp with the NEW key instead (that is what proves it works), or pass --force if deleting the newer key is really the intent.`);
+        }
+      }
+      if (live.length === 0 && !hasPasskey) {
+        const expiredNote = survivors.length > 0 ? " (the remaining key(s) have already expired)" : "";
+        throw new UnsafeRevocationError("NO_WORKING_CREDENTIAL", `This would leave "${user.userName}" with no working API key and no authenticator${expiredNote}, which is unrecoverable \u2014 a parent org cannot add credentials inside a sub-org. Run --add first. There is no --force for this.`);
+      }
+      if (durableSurvivors.length === 0 && !hasPasskey && !input.force) {
+        const deadlines = live.map((k) => `${k.apiKeyId} ("${k.apiKeyName}") expires ${k.expirationSeconds}s after creation`).join("; ");
+        throw new UnsafeRevocationError("ALL_SURVIVORS_EXPIRING", `Every key that would survive on "${user.userName}" has a TTL, so this schedules a lockout rather than causing one now: ${deadlines}. Add a key with no --expiration-seconds first, or pass --force if the expiry is intended.`);
+      }
+      return { targets, survivors, durableSurvivors };
+    }
+    function findApiKeyByPublicKey(user, publicKey) {
+      const want = publicKey.toLowerCase();
+      return user.apiKeys.find((k) => k.credential?.publicKey?.toLowerCase() === want);
+    }
+    function normalizeUser(user) {
+      return { ...user, apiKeys: user.apiKeys ?? [], authenticators: user.authenticators ?? [] };
+    }
+  }
+});
+
 // ../key-management/providers/turnkey/typescript/dist/admin/wallets.js
 var require_wallets = __commonJS({
   "../key-management/providers/turnkey/typescript/dist/admin/wallets.js"(exports2) {
@@ -3820,7 +5625,7 @@ var require_policies = __commonJS({
         policyName: "allowSignRawPayload",
         effect: "EFFECT_ALLOW",
         condition: `activity.type in ['ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2', 'ACTIVITY_TYPE_SIGN_RAW_PAYLOADS'] && activity.params.hash_function in ['HASH_FUNCTION_KECCAK256', 'HASH_FUNCTION_NOT_APPLICABLE']`,
-        notes: "Allows signRawPayload with the hash functions the agent runtime uses."
+        notes: "Allows signRawPayload with the hash functions the runtime uses: KECCAK256 (EIP-191/TIP-191/W3C proofs) and NOT_APPLICABLE (Solana ed25519 + EIP-712 typed data)."
       };
     }
     function buildDenyApproveToNonAllowedSpenderEvm(args) {
@@ -3963,6 +5768,19 @@ var require_sender_policies = __commonJS({
       "Ed25519SigVerify111111111111111111111111111"
       // Ed25519 (inner signature verification)
     ];
+    function solanaEscrowPrograms(value) {
+      const raw = value === void 0 ? [] : typeof value === "string" ? [value] : value;
+      const seen = /* @__PURE__ */ new Set();
+      const out = [];
+      for (const entry of raw) {
+        const id = typeof entry === "string" ? entry.trim() : "";
+        if (!id || seen.has(id))
+          continue;
+        seen.add(id);
+        out.push(id);
+      }
+      return out;
+    }
     function buildSenderPolicies(extras, chains) {
       const policies = [];
       policies.push({
@@ -4041,10 +5859,11 @@ var require_sender_policies = __commonJS({
           }
         }
         if (chain.kind === "solana") {
-          if (!extras.solanaEscrowProgramId) {
-            throw new Error(`Sender extras includes Solana chain but no solanaEscrowProgramId. Set it to Atum's escrow program ID for this deployment.`);
+          const escrowPrograms = solanaEscrowPrograms(extras.solanaEscrowProgramId);
+          if (escrowPrograms.length === 0) {
+            throw new Error(`Sender extras includes Solana chain but no solanaEscrowProgramId. Set it to Atum's escrow program ID for this deployment, or to a list of them.`);
           }
-          const allowed = [...SOLANA_STANDARD_PROGRAMS, extras.solanaEscrowProgramId];
+          const allowed = [...SOLANA_STANDARD_PROGRAMS, ...escrowPrograms];
           const list = allowed.map((p) => `'${p}'`).join(", ");
           policies.push({
             policyName: `allowedPrograms (${chain.chainId})`,
@@ -4159,7 +5978,7 @@ var require_extras_policies = __commonJS({
     var sender_policies_1 = require_sender_policies();
     var SPL_TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
     var ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
-    var EVM_ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+    var EVM_ADDRESS2 = /^0x[0-9a-fA-F]{40}$/;
     var TRON_ADDRESS = /^T[1-9A-HJ-NP-Za-km-z]{33}$/;
     var ALLOWED_EXTRAS_KEYS = [
       "allowedErc20Recipients",
@@ -4179,7 +5998,7 @@ var require_extras_policies = __commonJS({
         }
       }
       if (obj.allowedErc20Recipients != null) {
-        validateAddressMap(obj.allowedErc20Recipients, "allowedErc20Recipients", EVM_ADDRESS, source);
+        validateAddressMap(obj.allowedErc20Recipients, "allowedErc20Recipients", EVM_ADDRESS2, source);
       }
       if (obj.allowedTrc20Recipients != null) {
         validateAddressMap(obj.allowedTrc20Recipients, "allowedTrc20Recipients", TRON_ADDRESS, source);
@@ -4378,7 +6197,7 @@ var require_admin = __commonJS({
   "../key-management/providers/turnkey/typescript/dist/admin/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.validateExtras = exports2.buildExtrasPolicies = exports2.tronBase58ToEvmHex = exports2.TRON_PERMIT2 = exports2.EVM_PERMIT2 = exports2.buildSenderPolicies = exports2.listPolicies = exports2.derivePoliciesFromAllowlist = exports2.deletePolicy = exports2.buildDenyApproveToNonAllowedSpenderTron = exports2.buildDenyApproveToNonAllowedSpenderEvm = exports2.buildAllowSignRawPayloadPolicy = exports2.applyPolicies = exports2.createWalletWithChainAccounts = exports2.provisionAgentUser = exports2.deleteSubOrganization = exports2.listSubOrganizations = exports2.createSubOrganization = void 0;
+    exports2.validateExtras = exports2.buildExtrasPolicies = exports2.tronBase58ToEvmHex = exports2.TRON_PERMIT2 = exports2.EVM_PERMIT2 = exports2.buildSenderPolicies = exports2.listPolicies = exports2.derivePoliciesFromAllowlist = exports2.deletePolicy = exports2.buildDenyApproveToNonAllowedSpenderTron = exports2.buildDenyApproveToNonAllowedSpenderEvm = exports2.buildAllowSignRawPayloadPolicy = exports2.applyPolicies = exports2.createWalletWithChainAccounts = exports2.planRevocation = exports2.listUsers = exports2.isExpiredApiKey = exports2.isDurableApiKey = exports2.getUser = exports2.findApiKeyByPublicKey = exports2.deleteApiKeys = exports2.addApiKeys = exports2.UnsafeRevocationError = exports2.MAX_API_KEYS_PER_USER = exports2.listPendingActivities = exports2.getRootQuorum = exports2.getActivity = exports2.approvedVoterIds = exports2.approveActivity = exports2.provisionAgentUser = exports2.deleteSubOrganization = exports2.listSubOrganizations = exports2.createSubOrganization = void 0;
     var sub_organizations_1 = require_sub_organizations();
     Object.defineProperty(exports2, "createSubOrganization", { enumerable: true, get: function() {
       return sub_organizations_1.createSubOrganization;
@@ -4395,6 +6214,53 @@ var require_admin = __commonJS({
     Object.defineProperty(exports2, "provisionAgentUser", { enumerable: true, get: function() {
       return users_1.provisionAgentUser;
     } });
+    var activities_1 = require_activities();
+    Object.defineProperty(exports2, "approveActivity", { enumerable: true, get: function() {
+      return activities_1.approveActivity;
+    } });
+    Object.defineProperty(exports2, "approvedVoterIds", { enumerable: true, get: function() {
+      return activities_1.approvedVoterIds;
+    } });
+    Object.defineProperty(exports2, "getActivity", { enumerable: true, get: function() {
+      return activities_1.getActivity;
+    } });
+    Object.defineProperty(exports2, "getRootQuorum", { enumerable: true, get: function() {
+      return activities_1.getRootQuorum;
+    } });
+    Object.defineProperty(exports2, "listPendingActivities", { enumerable: true, get: function() {
+      return activities_1.listPendingActivities;
+    } });
+    var api_keys_1 = require_api_keys();
+    Object.defineProperty(exports2, "MAX_API_KEYS_PER_USER", { enumerable: true, get: function() {
+      return api_keys_1.MAX_API_KEYS_PER_USER;
+    } });
+    Object.defineProperty(exports2, "UnsafeRevocationError", { enumerable: true, get: function() {
+      return api_keys_1.UnsafeRevocationError;
+    } });
+    Object.defineProperty(exports2, "addApiKeys", { enumerable: true, get: function() {
+      return api_keys_1.addApiKeys;
+    } });
+    Object.defineProperty(exports2, "deleteApiKeys", { enumerable: true, get: function() {
+      return api_keys_1.deleteApiKeys;
+    } });
+    Object.defineProperty(exports2, "findApiKeyByPublicKey", { enumerable: true, get: function() {
+      return api_keys_1.findApiKeyByPublicKey;
+    } });
+    Object.defineProperty(exports2, "getUser", { enumerable: true, get: function() {
+      return api_keys_1.getUser;
+    } });
+    Object.defineProperty(exports2, "isDurableApiKey", { enumerable: true, get: function() {
+      return api_keys_1.isDurableApiKey;
+    } });
+    Object.defineProperty(exports2, "isExpiredApiKey", { enumerable: true, get: function() {
+      return api_keys_1.isExpiredApiKey;
+    } });
+    Object.defineProperty(exports2, "listUsers", { enumerable: true, get: function() {
+      return api_keys_1.listUsers;
+    } });
+    Object.defineProperty(exports2, "planRevocation", { enumerable: true, get: function() {
+      return api_keys_1.planRevocation;
+    } });
     var wallets_1 = require_wallets();
     Object.defineProperty(exports2, "createWalletWithChainAccounts", { enumerable: true, get: function() {
       return wallets_1.createWalletWithChainAccounts;
@@ -4445,7 +6311,7 @@ var require_admin = __commonJS({
 });
 
 // ../key-management/providers/turnkey/typescript/dist/index.js
-var require_dist6 = __commonJS({
+var require_dist8 = __commonJS({
   "../key-management/providers/turnkey/typescript/dist/index.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
@@ -4465,7 +6331,7 @@ var require_dist6 = __commonJS({
       for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.bytesFromHexOrBytes = exports2.signSecp256k1PreimageAndVerify = exports2.extractTronSignatureFromTransactionProtobuf = exports2.TurnkeyTronSigner = exports2.TurnkeySolanaSigner = exports2.TurnkeyEvmSigner = exports2.noopMeter = exports2.noopLogger = exports2.TURNKEY_RETRY_BACKOFF_MS = exports2.resolveTurnkeyAccountAddress = exports2.p1363ToDer = exports2.createTurnkeyStamper = exports2.createIsolatedTurnkeyClient = exports2.getOrCreateTurnkeyClient = exports2.TurnkeyClient = void 0;
+    exports2.bytesFromHexOrBytes = exports2.signSecp256k1PreimageAndVerify = exports2.extractTronSignatureFromTransactionProtobuf = exports2.TurnkeyTronSigner = exports2.encodePayload = exports2.TurnkeySolanaSigner = exports2.TurnkeyEvmSigner = exports2.noopMeter = exports2.noopLogger = exports2.TURNKEY_RETRY_BACKOFF_MS = exports2.resolveTurnkeyAccountAddress = exports2.p1363ToDer = exports2.createTurnkeyStamper = exports2.createIsolatedTurnkeyClient = exports2.getOrCreateTurnkeyClient = exports2.TurnkeyClient = void 0;
     var client_1 = require_client();
     Object.defineProperty(exports2, "TurnkeyClient", { enumerable: true, get: function() {
       return client_1.TurnkeyClient;
@@ -4500,15 +6366,18 @@ var require_dist6 = __commonJS({
     Object.defineProperty(exports2, "noopMeter", { enumerable: true, get: function() {
       return meter_1.noopMeter;
     } });
-    var evm_1 = require_evm2();
+    var evm_1 = require_evm3();
     Object.defineProperty(exports2, "TurnkeyEvmSigner", { enumerable: true, get: function() {
       return evm_1.TurnkeyEvmSigner;
     } });
-    var solana_1 = require_solana2();
+    var solana_1 = require_solana3();
     Object.defineProperty(exports2, "TurnkeySolanaSigner", { enumerable: true, get: function() {
       return solana_1.TurnkeySolanaSigner;
     } });
-    var tron_1 = require_tron2();
+    Object.defineProperty(exports2, "encodePayload", { enumerable: true, get: function() {
+      return solana_1.encodePayload;
+    } });
+    var tron_1 = require_tron3();
     Object.defineProperty(exports2, "TurnkeyTronSigner", { enumerable: true, get: function() {
       return tron_1.TurnkeyTronSigner;
     } });
@@ -4561,21 +6430,26 @@ async function resolveSenderAddresses(cfg) {
   return accounts.map((a) => ({ address: a.address, addressFormat: a.addressFormat }));
 }
 async function signWithTurnkeyClient(client, chainPrefix, cfg, message, messagePrehash) {
+  const pinnedAddress = requirePinnedSender(cfg.pinnedAddress);
   const deps = {
     walletId: cfg.walletId,
     log: cfg.logger ?? import_turnkey_signer.noopLogger,
     discoveryTimeoutMs: cfg.discoveryTimeoutMs ?? DEFAULTS.discoveryTimeoutMs,
-    ...cfg.pinnedAddress ? { pinnedAddress: cfg.pinnedAddress } : {}
+    ...pinnedAddress ? { pinnedAddress } : {}
   };
   switch (chainPrefix) {
     case "eip155": {
-      const { domain, types, message: typedMessage } = parsePrehash(messagePrehash, "EVM");
+      const { domain, types, message: typedMessage } = parsePrehash(messagePrehash, "EVM", message);
       const signer = new import_turnkey_signer.TurnkeyEvmSigner(client, deps);
       await signer.initialize();
       return { signature: await signer.signTypedData(domain, types, typedMessage) };
     }
     case "tron": {
-      const { domain, types, message: typedMessage } = parsePrehash(messagePrehash, "Tron");
+      const {
+        domain,
+        types,
+        message: typedMessage
+      } = parsePrehash(messagePrehash, "Tron", message);
       const signer = new import_turnkey_signer.TurnkeyTronSigner(client, deps);
       await signer.initialize();
       return { signature: await signer.signTypedData(domain, types, typedMessage) };
@@ -4603,7 +6477,7 @@ function decodeSolanaMessageHex(message) {
   }
   return Uint8Array.from(Buffer.from(hex, "hex"));
 }
-function parsePrehash(messagePrehash, label) {
+function parsePrehash(messagePrehash, label, advertisedDigest) {
   if (!messagePrehash) {
     throw new Error(`Turnkey ${label} signing requires signed_messages[0].message_prehash`);
   }
@@ -4615,15 +6489,29 @@ function parsePrehash(messagePrehash, label) {
   }
   const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
   if (!isObject(parsed) || !isObject(parsed.domain) || !isObject(parsed.types) || !isObject(parsed.message)) {
-    throw new Error(`Turnkey ${label} signing: message_prehash must be a JSON object with domain, types and message`);
+    throw new Error(
+      `Turnkey ${label} signing: message_prehash must be a JSON object with domain, types and message`
+    );
+  }
+  const { EIP712Domain: _derived, ...structTypes } = parsed.types;
+  const domain = parsed.domain;
+  const types = structTypes;
+  const message = parsed.message;
+  const prehashDigest = import_ethers6.TypedDataEncoder.hash(domain, types, message);
+  if (prehashDigest.toLowerCase() !== advertisedDigest.toLowerCase()) {
+    throw new Error(
+      `Turnkey ${label} signing: message_prehash implies digest ${prehashDigest} but message is ${advertisedDigest}`
+    );
   }
-  return { domain: parsed.domain, types: parsed.types, message: parsed.message };
+  return { domain, types, message };
 }
-var import_turnkey_signer, TURNKEY_API_URL, DEFAULTS;
+var import_turnkey_signer, import_ethers6, TURNKEY_API_URL, DEFAULTS;
 var init_turnkey_impl = __esm({
   "src/signers/turnkey-impl.ts"() {
     "use strict";
-    import_turnkey_signer = __toESM(require_dist6());
+    import_turnkey_signer = __toESM(require_dist8());
+    import_ethers6 = require("ethers");
+    init_pinned_address();
     TURNKEY_API_URL = "https://api.turnkey.com";
     DEFAULTS = {
       concurrencyLimit: 10,
@@ -4635,6 +6523,7 @@ var init_turnkey_impl = __esm({
 
 // src/cli/send-payment.ts
 var import_commander = require("commander");
+var import_fs = require("fs");
 
 // src/generated/core/OpenAPI.ts
 var Interceptors = class {
@@ -5068,8 +6957,26 @@ var PaymentsService = class {
    * 2. Find optimal settlement routes across chains/assets
    * 3. Secure funds in escrow
    * 4. Coordinate with settlement agents for execution
-   * 5. Return a real-time result if processing completes within 30 seconds,
-   * otherwise return a payment ID for status polling
+   * 5. Return a real-time result if settlement completes inside the synchronous window,
+   * otherwise return a payment ID and status for polling
+   *
+   * **Idempotency.** `request_id` is the idempotency key, scoped to the source account
+   * and originator. Submitting the same `request_id` again returns the ORIGINAL payment
+   * instead of charging a second time, so a client whose request timed out or failed
+   * in transit can safely re-submit.
+   *
+   * Because a re-submission must be admissible on its own, some fields legitimately
+   * differ between attempts and are excluded from the comparison: `quote_deadline` and
+   * `fulfillment_deadline` (both must be in the future, so a later attempt has to move
+   * them), and the `sender_auth` signature they are signed into.
+   *
+   * What must NOT differ is the payment's economics — source account and asset,
+   * destination accounts and assets, `fulfillment_amount`, and `max_source_amount` (the
+   * payer's own risk cap; lowering it on a retry describes a different payment, not the
+   * same one with less headroom). Re-using one `request_id` for a genuinely different
+   * payment is a client bug that would otherwise be silently collapsed onto the first
+   * payment, so it is rejected with `409` and `IDEMPOTENCY_TERMS_MISMATCH`. Use a
+   * distinct `request_id` per payment.
    *
    * @param data The data for the request.
    * @param data.requestBody
@@ -5086,9 +6993,14 @@ var PaymentsService = class {
         400: "Invalid request",
         401: "Signature or sender authorization could not be verified",
         403: "Payment declined during counterparty authorization",
+        409: `The \`request_id\` has already been used for a payment with different economics
+(\`IDEMPOTENCY_TERMS_MISMATCH\`). Re-submitting one \`request_id\` is how a retry is
+made safe, so it must identify one payment; use a distinct \`request_id\` per
+payment.
+`,
         413: "Payment request too large to process",
         500: "Internal server error",
-        503: "A dependency is temporarily unavailable"
+        503: "The request was not accepted: a dependency is temporarily unavailable, or this operation is paused (`SERVICE_PAUSED`). Nothing was submitted, so the request is safe to retry."
       }
     });
   }
@@ -5173,6 +7085,9 @@ var PaymentsService = class {
    *
    * The response includes everything needed to sign and submit a payment, except the signature itself.
    *
+   * Not available on every gateway or every source chain; where it is not, this
+   * returns `501`. Sign the returned request and submit it to `POST /v1/payments`.
+   *
    * @param data The data for the request.
    * @param data.requestBody
    * @returns PreparePaymentResponse Payment request prepared successfully
@@ -5219,11 +7134,30 @@ var AuthorizationsService = class {
       body: data.requestBody,
       mediaType: "application/json",
       errors: {
-        400: "Invalid payment request",
-        404: "Counterparty not found (no registration for the resolved DID)",
-        500: "Internal server error",
-        502: "Counterparty webhook error (HTTP error or connection failure)",
-        504: "Authorization timed out (counterparty did not respond)"
+        400: `The request was rejected before authorization was attempted, so no
+authorization outcome exists.
+`,
+        401: `The counterparty's proof was rejected (\`PROOF_INVALID\` or \`PROOF_STALE\`).
+This is an authorization outcome, so the body is an \`AuthorizationResult\`
+with \`status: error\`.
+`,
+        404: `Counterparty not found (no registration for the resolved DID). An
+authorization outcome, so the body is an \`AuthorizationResult\` with
+\`status: error\` and \`error_code: COUNTERPARTY_NOT_FOUND\`.
+`,
+        500: `Either shape, depending on where the failure happened. A failure before
+authorization was attempted returns \`ErrorResponse\`. A failure carrying an
+authorization outcome returns \`AuthorizationResult\` with \`status: error\`.
+`,
+        502: `Counterparty webhook error (HTTP error or connection failure). An
+authorization outcome, so the body is an \`AuthorizationResult\` with
+\`status: error\` and \`error_code: WEBHOOK_ERROR\` or
+\`WEBHOOK_CONNECTION_ERROR\`.
+`,
+        504: `Authorization timed out (the counterparty did not respond). An
+authorization outcome, so the body is an \`AuthorizationResult\` with
+\`status: timeout\`.
+`
       }
     });
   }
@@ -5250,6 +7184,31 @@ var QuoteRequestsService = class {
    * Collection continues server-side until the quote deadline regardless of the HTTP
    * connection, so quotes remain retrievable via the status endpoint in either mode.
    *
+   * **Idempotency.** `request_id` is the idempotency key, scoped to the source account
+   * and originator — the same key, and the same contract, as POST /v1/payments.
+   * Submitting the same `request_id` again returns the ORIGINAL batch instead of opening
+   * a second one, so a client whose request timed out or failed in transit can safely
+   * re-submit and recover its `quote_request_id`.
+   *
+   * Because a re-submission must be admissible on its own, some fields legitimately
+   * differ between attempts and are excluded from the comparison: `quote_deadline` and
+   * `fulfillment_deadline` (both must be in the future, so a later attempt has to move
+   * them) and the `proof` that covers them. An expired `quote_deadline` on a
+   * re-submission is NOT an error — the request is resolved onto the batch that already
+   * exists rather than used to open one. There is no `sender_auth` to re-sign here: this
+   * endpoint rejects it, because the spend authorization belongs to the award call.
+   *
+   * The collection window belongs to the BATCH, not to the request. Asking again with a
+   * later `quote_deadline` does not extend a window already open; `quote_deadline` in the
+   * response is the batch's own, and `status` says whether collection is still running.
+   *
+   * What must NOT differ is the corridor's economics — source account and asset,
+   * destination accounts and assets, `fulfillment_amount`, and `max_source_amount`.
+   * Re-using one `request_id` for a genuinely different corridor is a client bug that
+   * would otherwise be silently collapsed onto the first batch, returning quotes for a
+   * corridor that was never requested. It is rejected with `409` and
+   * `IDEMPOTENCY_TERMS_MISMATCH`. Use a distinct `request_id` per quote-request.
+   *
    * @param data The data for the request.
    * @param data.requestBody
    * @param data.wait Return a handle immediately (`false`, default) or hold the connection for collected quotes (`true`).
@@ -5269,8 +7228,19 @@ var QuoteRequestsService = class {
       body: data.requestBody,
       mediaType: "application/json",
       errors: {
-        400: "Invalid request",
-        500: "Internal server error"
+        400: `Invalid request. \`QUOTE_DEADLINE_NOT_FUTURE\` is the one worth planning for: a NEW
+quote-request whose \`quote_deadline\` has already passed is refused, because there is
+no window left to collect quotes in. It does not apply to a re-submission \u2014 an
+already-used \`request_id\` resolves onto the batch that exists and its expired
+deadline is ignored, which is what makes a retry recoverable.
+`,
+        409: `The \`request_id\` has already been used for a quote-request with different
+economics (\`IDEMPOTENCY_TERMS_MISMATCH\`). Re-submitting one \`request_id\` is how a
+retry is made safe, so it must identify one batch; use a distinct \`request_id\`
+per quote-request.
+`,
+        500: "Internal server error",
+        503: "The request was not accepted: a dependency is temporarily unavailable, or this operation is paused (`SERVICE_PAUSED`). Nothing was submitted, so the request is safe to retry."
       }
     });
   }
@@ -5353,6 +7323,43 @@ var QuoteRequestsService = class {
     });
   }
 };
+var ChainDefaultsService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Get chain defaults
+   * The addresses needed to build a payment on a chain: the escrow, the accounts named
+   * in the deposit authorization, and the fulfillment verifier. Fetch these rather than
+   * hardcoding them - they change when a chain's contracts are redeployed.
+   *
+   * With `chain_id`, returns that chain. Without it, or with an empty value, returns
+   * every chain the gateway serves, keyed by CAIP-2 chain id.
+   *
+   * A chain that is not fully configured is still returned when asked for by
+   * `chain_id`, with the missing address empty, but is left out of the full listing.
+   * Treat an empty address as a chain you cannot pay on.
+   *
+   * @param data The data for the request.
+   * @param data.chainId CAIP-2 chain identifier. Omit it, or send it empty, to receive every chain the gateway serves, keyed by chain id.
+   * @returns GetDefaultsResult Chain defaults. A single object when `chain_id` was supplied, otherwise an object keyed by CAIP-2 chain id.
+   * @throws ApiError
+   */
+  getDefaults(data = {}) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/defaults",
+      query: {
+        chain_id: data.chainId
+      },
+      errors: {
+        400: "The `chain_id` is not a valid CAIP-2 chain identifier",
+        404: "The requested chain is not served by this gateway, or - when `chain_id` was omitted - no chain could be resolved at all",
+        503: "A dependency is temporarily unavailable"
+      }
+    });
+  }
+};
 var HealthService = class {
   constructor(httpRequest) {
     this.httpRequest = httpRequest;
@@ -5390,19 +7397,126 @@ var PaymentGatewayClient = class {
       }
     });
     this.authorizations = new AuthorizationsService(this.request);
+    this.chainDefaults = new ChainDefaultsService(this.request);
     this.health = new HealthService(this.request);
     this.payments = new PaymentsService(this.request);
     this.quoteRequests = new QuoteRequestsService(this.request);
   }
 };
 
+// src/errors.ts
+var GatewayTimeoutError = class extends Error {
+  constructor(baseUrl, timeoutMs) {
+    super(
+      `Gateway at ${baseUrl || "(same origin)"} did not respond within ${formatSeconds(timeoutMs)}`
+    );
+    this.baseUrl = baseUrl;
+    this.timeoutMs = timeoutMs;
+    this.name = "GatewayTimeoutError";
+  }
+};
+function formatSeconds(ms) {
+  const seconds = ms / 1e3;
+  return `${Number.isInteger(seconds) ? seconds : seconds.toFixed(1)}s`;
+}
+function isGatewayTimeoutError(err) {
+  return err instanceof GatewayTimeoutError;
+}
+function isApiError(err) {
+  return err instanceof ApiError;
+}
+
+// src/request-timeout.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_SYNC_WAIT_TIMEOUT_MS = 12e4;
+var SYNC_HOLD_PATHS = ["/v1/payments", "/v1/payments/awards"];
+function pathOf(url) {
+  if (!url) return "";
+  const path = url.split("?")[0];
+  const scheme = path.indexOf("://");
+  if (scheme === -1) return path;
+  const host = path.indexOf("/", scheme + 3);
+  return host === -1 ? "" : path.slice(host);
+}
+function hasWaitTrueQuery(url) {
+  const query = url?.indexOf("?") ?? -1;
+  if (query === -1) return false;
+  return new URLSearchParams(url.slice(query + 1)).get("wait") === "true";
+}
+function isSyncWaitRequest({ method, url, wait }) {
+  if (wait === true || wait === "true" || hasWaitTrueQuery(url)) return true;
+  if (method?.toUpperCase() !== "POST") return false;
+  const path = pathOf(url);
+  return SYNC_HOLD_PATHS.some((held) => path === held || path.endsWith(held));
+}
+function ordinaryTimeout(timeouts = {}) {
+  return timeouts.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+}
+function timeoutForRequest(request2, timeouts = {}) {
+  return isSyncWaitRequest(request2) ? timeouts.syncWaitTimeoutMs ?? DEFAULT_SYNC_WAIT_TIMEOUT_MS : ordinaryTimeout(timeouts);
+}
+function applyRequestTimeout(timeouts = {}) {
+  return (config2) => ({
+    ...config2,
+    timeout: config2.timeout ?? timeoutForRequest({ method: config2.method, url: config2.url }, timeouts)
+  });
+}
+function isAxiosTimeout(error) {
+  const failure = error;
+  if (!failure) return false;
+  if (failure.code === "ECONNABORTED" || failure.code === "ETIMEDOUT") return true;
+  return failure.code === "ERR_BAD_RESPONSE" && /stream has been aborted/i.test(failure.message ?? "");
+}
+function translateTimeout(error, baseUrl, fallbackTimeoutMs) {
+  if (!isAxiosTimeout(error)) return error;
+  const configured = error.config?.timeout;
+  return new GatewayTimeoutError(baseUrl, configured ?? fallbackTimeoutMs);
+}
+
+// src/timeout-http-request.ts
+function withRequestTimeout(config2, timeouts) {
+  const request2 = new Interceptors();
+  for (const fn of config2?.interceptors?.request?._fns ?? []) request2.use(fn);
+  request2.use(applyRequestTimeout(timeouts));
+  return {
+    interceptors: { request: request2, response: config2?.interceptors?.response ?? new Interceptors() }
+  };
+}
+var TimeoutHttpRequest = class extends AxiosHttpRequest {
+  constructor(config2, timeouts = {}) {
+    super(config2);
+    this.timeouts = timeouts;
+  }
+  request(options) {
+    return new CancelablePromise((resolve2, reject, onCancel) => {
+      const pending = super.request(options);
+      onCancel(() => pending.cancel());
+      pending.then(resolve2, (error) => {
+        const request2 = { method: options.method, url: options.url, wait: options.query?.wait };
+        reject(
+          translateTimeout(error, this.config.BASE, timeoutForRequest(request2, this.timeouts))
+        );
+      });
+    });
+  }
+};
+function timeoutHttpRequest(timeouts) {
+  return class extends TimeoutHttpRequest {
+    constructor(config2) {
+      super(config2, timeouts);
+    }
+  };
+}
+
 // src/chain-adapters/evm.ts
 var import_ethers = require("ethers");
 
 // src/chain-adapters/types.ts
 function assertKeyMatchesSender(matches, sender, derived) {
   if (!matches) {
-    throw new Error(`The private key derives ${derived}, which does not match the sender address ${sender}`);
+    throw new Error(
+      `The private key derives ${derived}, which does not match the sender address ${sender}`
+    );
   }
 }
 
@@ -5454,10 +7568,9 @@ var tronAdapter = {
       throw new Error("Invalid private key");
     }
   },
-  // Tron addresses are the same secp256k1-derived 20 bytes as EVM. Compare the
-  // derived hex directly against the canonical sender; do NOT run normalizeAddress
-  // on the derived side — it strips a leading 41, which would corrupt an address
-  // whose first byte is 0x41.
+  // Tron addresses are the same secp256k1-derived 20 bytes as EVM. The derived
+  // address is already canonical 20-byte hex, so only the sender side — which
+  // arrives in whichever spelling the caller chose — needs normalizing.
   verifyAddressMatchesKey(privateKey, address) {
     const key = privateKey.startsWith("0x") ? privateKey : "0x" + privateKey;
     const derived = new import_ethers2.ethers.Wallet(key).address;
@@ -5496,22 +7609,133 @@ function secretKeyFromPrivate(privateKey) {
   if (decoded.length === 32) {
     return import_tweetnacl.default.sign.keyPair.fromSeed(decoded).secretKey;
   }
-  throw new Error(`Invalid Solana private key length: expected 32 or 64 bytes, got ${decoded.length}`);
+  throw new Error(
+    `Invalid Solana private key length: expected 32 or 64 bytes, got ${decoded.length}`
+  );
 }
 
 // src/chain-adapters/index.ts
 var adapters = {
-  "eip155": evmAdapter,
-  "tron": tronAdapter,
-  "solana": solanaAdapter
+  eip155: evmAdapter,
+  tron: tronAdapter,
+  solana: solanaAdapter
 };
 function getChainAdapter(sourceChainId) {
-  const prefix = sourceChainId.split(":")[0];
+  const prefix = sourceChainId.split(":")[0]?.toLowerCase() ?? "";
   const adapter = adapters[prefix];
   if (!adapter) throw new Error(`Unsupported source chain: ${sourceChainId}`);
   return adapter;
 }
 
+// src/asset-identifier.ts
+var import_ethers3 = require("ethers");
+var SHAPE_EXAMPLE = "eip155:421614/erc20:0x...";
+var NAMESPACE = /^[a-z0-9]+$/;
+var CHAIN_REFERENCE = /^[a-zA-Z0-9_-]+$/;
+var ASSET_NAMESPACE = /^[a-z0-9-]{3,8}$/;
+var ASSET_REFERENCE = /^[-.%a-zA-Z0-9]{1,128}$/;
+var TOKEN_ID = /^[-.%a-zA-Z0-9]{1,78}$/;
+var EVM_ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+var EIP155_REFERENCE = /^[0-9]+$/;
+var HEX_REFERENCE = /^0[xX][0-9a-fA-F]{1,16}$/;
+var MAX_ECHO = 120;
+var MAX_REFERENCE_ECHO = 32;
+function parseAssetIdentifier(value) {
+  if (typeof value !== "string" || value === "") {
+    throw new Error(shapeError(value));
+  }
+  const firstSlash = value.indexOf("/");
+  if (firstSlash === -1) {
+    throw new Error(shapeError(value));
+  }
+  const chainSegments = value.slice(0, firstSlash).split(":");
+  if (chainSegments.length !== 2) {
+    throw new Error(shapeError(value));
+  }
+  const namespace = chainSegments[0].toLowerCase();
+  const reference = namespace === "tron" ? chainSegments[1].toLowerCase() : chainSegments[1];
+  if (!NAMESPACE.test(namespace) || !CHAIN_REFERENCE.test(reference)) {
+    throw new Error(shapeError(value));
+  }
+  if (namespace === "eip155" && !EIP155_REFERENCE.test(reference)) {
+    throw new Error(eip155ReferenceError(reference, value));
+  }
+  const assetPart = value.slice(firstSlash + 1);
+  const separator = assetPart.indexOf(":");
+  if (separator === -1) {
+    throw new Error(tokenAddressError(value));
+  }
+  const assetNamespace = assetPart.slice(0, separator).toLowerCase();
+  const rest = assetPart.slice(separator + 1);
+  const referenceSlash = rest.indexOf("/");
+  const tokenAddress = referenceSlash === -1 ? rest : rest.slice(0, referenceSlash);
+  const tokenId = referenceSlash === -1 ? void 0 : rest.slice(referenceSlash + 1);
+  if (!ASSET_NAMESPACE.test(assetNamespace)) {
+    throw new Error(tokenAddressError(value));
+  }
+  if (assetNamespace === "slip44") {
+    throw new Error(nativeAssetError(value));
+  }
+  if (!ASSET_REFERENCE.test(tokenAddress)) {
+    throw new Error(tokenAddressError(value));
+  }
+  if (tokenId !== void 0 && !TOKEN_ID.test(tokenId)) {
+    throw new Error(tokenAddressError(value));
+  }
+  assertTokenAddress(namespace, tokenAddress, value);
+  const chainId = `${namespace}:${reference}`;
+  return {
+    chainId,
+    namespace,
+    reference,
+    assetNamespace,
+    tokenAddress,
+    ...tokenId === void 0 ? {} : { tokenId },
+    normalized: `${chainId}/${assetNamespace}:${tokenAddress}${tokenId === void 0 ? "" : `/${tokenId}`}`
+  };
+}
+function assetChainId(value) {
+  return parseAssetIdentifier(value).chainId;
+}
+function echo(value, limit = MAX_ECHO) {
+  const shown = typeof value === "string" ? value : String(value);
+  return shown.length > limit ? `${shown.slice(0, limit)}\u2026` : shown;
+}
+function shapeError(value) {
+  return `Invalid asset identifier "${echo(value)}": expected CAIP-19 "<chain>/<type>:<address>", e.g. ${SHAPE_EXAMPLE}`;
+}
+function tokenAddressError(value) {
+  return `Invalid token address in asset "${echo(value)}".`;
+}
+function eip155ReferenceError(reference, value) {
+  const prefix = `Invalid eip155 chain id "${echo(reference, MAX_REFERENCE_ECHO)}" in asset "${echo(value)}"`;
+  if (HEX_REFERENCE.test(reference)) {
+    return `${prefix}: use the decimal chain id (${BigInt(reference)}), not hex.`;
+  }
+  return `${prefix}: an eip155 chain id is decimal, e.g. 421614.`;
+}
+function nativeAssetError(value) {
+  return `Asset "${echo(value)}" is a native asset (slip44) and has no contract to deposit. Use the wrapped token's erc20 identifier.`;
+}
+function assertTokenAddress(namespace, tokenAddress, value) {
+  if (namespace !== "eip155") return;
+  if (!EVM_ADDRESS.test(tokenAddress)) {
+    throw new Error(tokenAddressError(value));
+  }
+  const body = tokenAddress.slice(2);
+  if (body === body.toLowerCase() || body === body.toUpperCase()) return;
+  try {
+    (0, import_ethers3.getAddress)(tokenAddress);
+  } catch {
+    throw new Error(
+      `Token address "${tokenAddress}" has an invalid checksum. Fix the capitalization or use the all-lowercase form.`
+    );
+  }
+}
+
+// src/index.ts
+var import_chain_address = __toESM(require_dist2());
+
 // src/chain-adapters/solana-clock.ts
 var DEFAULT_SOLANA_RPC_URLS = {
   "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp": "https://api.mainnet-beta.solana.com",
@@ -5580,19 +7804,84 @@ async function resolveSolanaIssuedAt(opts) {
 }
 
 // src/index.ts
-var import_payment_request_sender_auth2 = __toESM(require_dist4());
+var import_payment_request_sender_auth2 = __toESM(require_dist5());
+var import_chain_address2 = __toESM(require_dist2());
+
+// src/payment-tracking.ts
+function isTerminalStatus(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+var DEFAULT_WAIT_SECONDS = 60;
+var DEFAULT_WAIT_BUDGET_MS = DEFAULT_WAIT_SECONDS * 1e3;
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+async function waitForTerminalStatus(params) {
+  const {
+    fetchStatus,
+    budgetMs = DEFAULT_WAIT_BUDGET_MS,
+    intervalMs = DEFAULT_POLL_INTERVAL_MS,
+    now = () => Date.now(),
+    signal,
+    // Closes over `signal` so the default wakes on abort instead of sleeping out the interval.
+    sleep = (ms) => defaultSleep(ms, signal),
+    onError
+  } = params;
+  const deadline = now() + budgetMs;
+  let snapshot;
+  let errorCount = 0;
+  while (now() < deadline) {
+    if (signal?.aborted) {
+      return { snapshot, timedOut: true, aborted: true, errorCount };
+    }
+    const remaining = deadline - now();
+    await sleep(Math.min(intervalMs, remaining));
+    if (signal?.aborted) {
+      return { snapshot, timedOut: true, aborted: true, errorCount };
+    }
+    try {
+      snapshot = await fetchStatus();
+    } catch (error) {
+      errorCount += 1;
+      onError?.(error);
+      continue;
+    }
+    if (isTerminalStatus(snapshot.status)) {
+      return { snapshot, timedOut: false, aborted: false, errorCount };
+    }
+  }
+  return { snapshot, timedOut: true, aborted: false, errorCount };
+}
+function defaultSleep(ms, signal) {
+  if (!signal) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+  return new Promise((resolve2) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve2();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+
+// src/index.ts
+var import_payment_request_token_approval = __toESM(require_dist6());
 
 // src/sender_auth_schemes/evm_permit2.ts
-var import_ethers3 = require("ethers");
-var import_evm_escrow_encoding = __toESM(require_dist2());
+var import_ethers4 = require("ethers");
+var import_evm_escrow_encoding = __toESM(require_dist3());
 
 // src/sender_auth_schemes/solana.ts
-var import_ethers4 = require("ethers");
+var import_ethers5 = require("ethers");
 var import_bs582 = __toESM(require("bs58"));
-var import_solana_escrow_encoding = __toESM(require_dist3());
+var import_solana_escrow_encoding = __toESM(require_dist4());
+
+// src/signers/index.ts
+init_pinned_address();
 
 // src/signers/raw.ts
-var import_payment_request_sender_auth = __toESM(require_dist4());
+var import_payment_request_sender_auth = __toESM(require_dist5());
 var RawSenderSigner = class {
   constructor(network, privateKey) {
     const adapter = getChainAdapter(network);
@@ -5605,6 +7894,7 @@ var RawSenderSigner = class {
 };
 
 // src/signers/turnkey.ts
+init_pinned_address();
 async function loadImpl() {
   return Promise.resolve().then(() => (init_turnkey_impl(), turnkey_impl_exports));
 }
@@ -5613,6 +7903,7 @@ var TurnkeySenderSigner = class {
     this.chainPrefix = chainPrefix;
     this.cfg = cfg;
     this.loader = loader;
+    this.pinnedAddress = requirePinnedSender(cfg.pinnedAddress);
   }
   async sign(signedMessage) {
     const impl = await this.loader();
@@ -5623,7 +7914,7 @@ var TurnkeySenderSigner = class {
         walletId: this.cfg.walletId,
         apiPublicKey: this.cfg.apiPublicKey,
         apiPrivateKey: this.cfg.apiPrivateKey,
-        ...this.cfg.pinnedAddress ? { pinnedAddress: this.cfg.pinnedAddress } : {},
+        ...this.pinnedAddress ? { pinnedAddress: this.pinnedAddress } : {},
         ...this.cfg.logger ? { logger: this.cfg.logger } : {},
         ...this.cfg.meter ? { meter: this.cfg.meter } : {}
       },
@@ -5635,24 +7926,30 @@ var TurnkeySenderSigner = class {
 
 // src/signers/index.ts
 function createSenderSigner(sourceChainId, opts) {
-  const chainPrefix = sourceChainId.split(":")[0];
+  const chainPrefix = sourceChainId.split(":")[0]?.toLowerCase() ?? "";
   if (opts.provider === "turnkey") {
     return new TurnkeySenderSigner(chainPrefix, opts);
   }
+  const pinnedAddress = requirePinnedSender(opts.pinnedAddress);
   const adapter = getChainAdapter(sourceChainId);
   const privateKey = adapter.formatPrivateKey(opts.privateKey);
   adapter.validatePrivateKey?.(opts.privateKey);
-  if (opts.pinnedAddress) {
+  if (pinnedAddress) {
     if (!adapter.verifyAddressMatchesKey) {
-      throw new Error(`pinnedAddress was provided but the ${sourceChainId} adapter cannot verify the key derives it`);
+      throw new Error(
+        `pinnedAddress was provided but the ${sourceChainId} adapter cannot verify the key derives it`
+      );
     }
-    adapter.verifyAddressMatchesKey(privateKey, opts.pinnedAddress);
+    adapter.verifyAddressMatchesKey(privateKey, pinnedAddress);
   }
   return new RawSenderSigner(sourceChainId, opts.privateKey);
 }
 
 // src/index.ts
 var PAYMENT_REQUEST_VERSION = "1.0";
+function assertPayableAccount(assetIdentifier, account) {
+  (0, import_chain_address.validate)(assetChainId(assetIdentifier), account);
+}
 var defaultGateway = "https://payment-gw.production-testnet.atum.xyz";
 var OpenAPI2 = { ...OpenAPI, BASE: defaultGateway };
 var DEFAULT_QUOTE_DEADLINE_SECONDS = 5;
@@ -5669,10 +7966,14 @@ function resolveDeadlines(params, defaultQuoteSeconds) {
   const quoteDeadlineSeconds = params.quoteDeadlineSeconds ?? defaultQuoteSeconds;
   const fulfillmentDeadlineSeconds = params.fulfillmentDeadlineSeconds ?? DEFAULT_FULFILLMENT_DEADLINE_SECONDS;
   if (!Number.isFinite(quoteDeadlineSeconds) || !Number.isFinite(fulfillmentDeadlineSeconds)) {
-    throw new Error("quoteDeadlineSeconds and fulfillmentDeadlineSeconds must be finite numbers of seconds.");
+    throw new Error(
+      "quoteDeadlineSeconds and fulfillmentDeadlineSeconds must be finite numbers of seconds."
+    );
   }
   if (quoteDeadlineSeconds <= 0 || fulfillmentDeadlineSeconds <= 0) {
-    throw new Error("quoteDeadlineSeconds and fulfillmentDeadlineSeconds must be positive numbers of seconds.");
+    throw new Error(
+      "quoteDeadlineSeconds and fulfillmentDeadlineSeconds must be positive numbers of seconds."
+    );
   }
   if (quoteDeadlineSeconds >= fulfillmentDeadlineSeconds) {
     throw new Error(
@@ -5685,18 +7986,67 @@ function resolveDeadlines(params, defaultQuoteSeconds) {
     fulfillment_deadline: new Date(now + fulfillmentDeadlineSeconds * 1e3).toISOString()
   };
 }
+function defaultsErrorDetail(error) {
+  if (!isApiError(error)) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  const body = error.body;
+  const parts = [];
+  if (typeof body?.code === "string" && body.code.trim() !== "") parts.push(body.code);
+  if (typeof body?.message === "string" && body.message.trim() !== "") parts.push(body.message);
+  const requestId = typeof body?.request_id === "string" && body.request_id.trim() !== "" ? body.request_id : "";
+  if (parts.length > 0) {
+    return `${parts.join(": ")}${requestId === "" ? "" : ` (request_id=${requestId})`}`;
+  }
+  return error.statusText || `HTTP ${error.status}`;
+}
+function singleChainOf(response, chainId) {
+  if (typeof response !== "object" || response === null) {
+    throw new Error(
+      `Failed to fetch defaults for chain ${chainId}: the gateway did not return a JSON object. Check that the configured base URL points at the payment gateway.`
+    );
+  }
+  const single = response;
+  if (typeof single.chain_id !== "string") {
+    throw new Error(
+      `Failed to fetch defaults for chain ${chainId}: the gateway answered with defaults for every chain rather than the one requested`
+    );
+  }
+  if (single.chain_id.toLowerCase() !== chainId.toLowerCase()) {
+    throw new Error(
+      `Failed to fetch defaults for chain ${chainId}: the gateway answered with defaults for ` + single.chain_id
+    );
+  }
+  return single;
+}
 async function assemblePaymentRequest(params) {
-  const sourceChainId = params.sourceAsset.split("/")[0];
-  const namespace = sourceChainId.split(":")[0];
+  const source = parseAssetIdentifier(params.sourceAsset);
+  const destination = parseAssetIdentifier(params.destinationAsset);
+  const { chainId: sourceChainId, namespace } = source;
   const adapter = getChainAdapter(sourceChainId);
   const nonce = params.nonce ?? (namespace === "solana" ? (0, import_payment_request_sender_auth2.deterministicSolanaNonce)({ requestId: params.requestId, depositor: params.depositor }) : (0, import_payment_request_sender_auth2.deterministicPermitNonce)({ requestId: params.requestId, depositor: params.depositor }));
   const auth = await (0, import_payment_request_sender_auth2.getChainAdapter)(sourceChainId).buildAuthMessage({
-    sourceAsset: params.sourceAsset,
+    // Canonicalized: the Tron adapter resolves its Permit2 address by exact chain-id key, so an
+    // uppercase namespace would miss the lookup and fail inside the SDK.
+    sourceAsset: source.normalized,
     depositor: params.depositor,
     // The gateway pins the signed deposit amount to max_source_amount (the cap).
     maxSourceAmount: params.maxSourceAmount,
     requestId: params.requestId,
     sourceDefaults: params.sourceDefaults,
+    // The payee the deposit commits to. Passed as CAIP components, not a composed string:
+    // the adapter composes it through the shared buildEscrowDestination so this producer
+    // and the release signer cannot disagree by a byte. These are the SAME two values that
+    // become paymentRequest.destination[0] below, so the signed commitment and the request
+    // body cannot describe different payees.
+    // Canonicalized for the same reason `sourceAsset` is, and additionally because the claim
+    // three lines up has to be TRUE: destination[0] below carries `destination.normalized`, so
+    // passing the raw string here would sign a commitment over different bytes than the request
+    // body names whenever a caller supplies a non-canonical namespace (e.g. "EIP155:42220").
+    // `normalized` lowercases only the namespaces and the asset namespace — the chain reference
+    // and token address keep their case, so base58 (Solana genesis reference, SPL mint) survives.
+    destinationAsset: destination.normalized,
+    destinationAccount: params.destinationAccount,
     deadline: params.deadline,
     nonce,
     ...namespace === "solana" ? {
@@ -5712,13 +8062,15 @@ async function assemblePaymentRequest(params) {
     version: params.version ?? PAYMENT_REQUEST_VERSION,
     request_id: params.requestId,
     source: {
-      asset_identifier: params.sourceAsset,
+      asset_identifier: source.normalized,
       account: params.depositor
     },
-    destination: [{
-      asset_identifier: params.destinationAsset,
-      account: params.destinationAccount
-    }],
+    destination: [
+      {
+        asset_identifier: destination.normalized,
+        account: params.destinationAccount
+      }
+    ],
     fulfillment_amount: params.fulfillmentAmount,
     max_source_amount: params.maxSourceAmount,
     quote_deadline: params.quoteDeadline,
@@ -5733,43 +8085,58 @@ async function assemblePaymentRequest(params) {
     ...params.settlerRequirements ? { settler_requirements: params.settlerRequirements } : {},
     sender_auth: {
       message_scheme: auth.messageScheme,
-      signed_messages: [{
-        message: auth.messageHash,
-        message_prehash: auth.messagePrehash,
-        signature: ""
-      }]
+      signed_messages: [
+        {
+          message: auth.messageHash,
+          message_prehash: auth.messagePrehash,
+          signature: ""
+        }
+      ]
     }
   };
 }
 var PaymentGatewayClient2 = class extends PaymentGatewayClient {
-  constructor(config2, HttpRequest = AxiosHttpRequest) {
+  constructor(config2, HttpRequest) {
     const envBase = (typeof process !== "undefined" ? process.env.GATEWAY_URL : void 0)?.trim();
     const base = config2?.BASE ?? (envBase || defaultGateway);
-    super({ ...config2, BASE: base }, HttpRequest);
-    this.baseUrl = base;
+    const timeouts = {
+      timeoutMs: config2?.timeoutMs,
+      syncWaitTimeoutMs: config2?.syncWaitTimeoutMs
+    };
+    super(
+      { ...config2, BASE: base, ...withRequestTimeout(config2, timeouts) },
+      HttpRequest ?? timeoutHttpRequest(timeouts)
+    );
   }
   /**
    * Fetches chain defaults from the payment gateway.
-   * 
+   *
+   * Goes through the generated typed client, so the request shares the payment calls'
+   * transport: one base URL, one timeout policy, and `/v1/defaults` is described by the
+   * OpenAPI contract rather than assembled by hand here.
+   *
    * @param chainId The CAIP-2 chain identifier (e.g., "eip155:42161")
    * @returns The chain defaults including escrow, quote selector, and fulfillment verifier
    */
   async fetchChainDefaults(chainId) {
-    const response = await fetch(`${this.baseUrl}/defaults?chain_id=${chainId}`);
-    if (!response.ok) {
-      let availableDefaults = null;
-      try {
-        const allDefaultsResponse = await fetch(`${this.baseUrl}/defaults`);
-        if (allDefaultsResponse.ok) {
-          availableDefaults = await allDefaultsResponse.json();
+    if (chainId.trim() === "") {
+      throw new Error(
+        'payment-gateway-client: fetchChainDefaults requires a CAIP-2 chain id, for example "eip155:8453"'
+      );
+    }
+    let response;
+    try {
+      response = await this.chainDefaults.getDefaults({ chainId });
+    } catch (error) {
+      if (isGatewayTimeoutError(error)) throw error;
+      throw new Error(
+        `Failed to fetch defaults for chain ${chainId}: ${defaultsErrorDetail(error)}`,
+        {
+          cause: error
         }
-      } catch {
-      }
-      const error = new Error(`Failed to fetch defaults for chain ${chainId}: ${response.statusText}`);
-      error.availableDefaults = availableDefaults;
-      throw error;
+      );
     }
-    const data = await response.json();
+    const data = singleChainOf(response, chainId);
     if (!data.escrow_contract) {
       throw new Error("defaults missing escrow_contract");
     }
@@ -5788,23 +8155,34 @@ var PaymentGatewayClient2 = class extends PaymentGatewayClient {
     if (!data.fulfillment_verifier.endpoint) {
       throw new Error("defaults missing fulfillment_verifier.endpoint");
     }
+    if (typeof data.permit2_contract === "string" && data.permit2_contract.trim() === "") {
+      throw new Error("defaults returned an empty permit2_contract");
+    }
     return {
       escrowContract: data.escrow_contract,
       quoteSelector: data.quote_selector,
       fulfillmentVerifierAccount: data.fulfillment_verifier.account,
       fulfillmentVerifierEndpoint: data.fulfillment_verifier.endpoint,
       fulfillmentProxy: data.fulfillment_proxy,
-      permit2Contract: data.permit2_contract,
+      // `?? undefined` normalises a JSON null at the boundary. The declared type is
+      // `string | undefined`, and a consumer testing `!== undefined` or `in` - both
+      // reasonable against that type - would otherwise build an EIP-712 domain around a
+      // null verifyingContract.
+      permit2Contract: data.permit2_contract ?? void 0,
+      // Which deposit witness the escrow on this chain pins (CORE-2033). Absent means the
+      // four-member CORE-2120 witness — see ChainDefaults.depositWitnessVersion for why
+      // absence is the permissive default. EVM/Tron only; Solana uses the svm_* fields below.
+      depositWitnessVersion: data.deposit_witness_version ?? void 0,
       // V3 Solana escrow domain separation. Present only for Solana
       // source chains; the Solana adapter requires them to build the deposit hash.
-      svmSignatureClusterId: data.svm_signature_cluster_id,
-      svmSignatureDomainVersion: data.svm_signature_domain_version
+      svmSignatureClusterId: data.svm_signature_cluster_id ?? void 0,
+      svmSignatureDomainVersion: data.svm_signature_domain_version ?? void 0
     };
   }
   /**
    * Prepares a payment request with defaults, ready for signing.
    *
-   * By default this resolves the corridor addresses from the gateway `/defaults`
+   * By default this resolves the corridor addresses from the gateway `/v1/defaults`
    * endpoint. It reaches the gateway only for what the caller has NOT already
    * supplied via `resolvedDefaults`: supply `resolvedDefaults.source` to skip the
    * source-chain fetch and `resolvedDefaults.destination` to skip the destination
@@ -5834,10 +8212,14 @@ var PaymentGatewayClient2 = class extends PaymentGatewayClient {
    * @returns A complete PaymentRequest object without the signature
    */
   async preparePaymentRequest(params) {
+    assertPayableAccount(params.destinationAsset, params.destinationAccount);
     const now = (params.now ?? Date.now)();
-    const { quote_deadline, fulfillment_deadline } = resolveDeadlines({ ...params, now: () => now }, DEFAULT_PAYMENT_QUOTE_DEADLINE_SECONDS);
-    const sourceChainId = params.sourceAsset.split("/")[0];
-    const destChainId = params.destinationAsset.split("/")[0];
+    const { quote_deadline, fulfillment_deadline } = resolveDeadlines(
+      { ...params, now: () => now },
+      DEFAULT_PAYMENT_QUOTE_DEADLINE_SECONDS
+    );
+    const sourceChainId = assetChainId(params.sourceAsset);
+    const destChainId = assetChainId(params.destinationAsset);
     const [sourceDefaults, fulfillmentProxy] = await Promise.all([
       params.resolvedDefaults?.source ?? this.fetchChainDefaults(sourceChainId),
       params.resolvedDefaults?.destination?.fulfillmentProxy ?? this.fetchChainDefaults(destChainId).then((d) => d.fulfillmentProxy)
@@ -5907,7 +8289,7 @@ var PaymentGatewayClient2 = class extends PaymentGatewayClient {
    * defaults and populates the SAME contract fields (`escrow_contract_address`,
    * `quote_selector`, `fulfillment_verifier`, `fulfillment_proxy`). These are not
    * optional in practice: the gateway requires `fulfillment_verifier` to build the
-   * QuoteRequested event it broadcasts to settlers, so the quote-request body
+   * request event it broadcasts to settlers, so the quote-request body
    * must carry the identical contract fields the payment flow does. The ONLY
    * field this drops relative to `preparePaymentRequest` is `sender_auth`, which
    * is supplied at award time (quote-time is unauthenticated — no signing, no
@@ -5917,26 +8299,38 @@ var PaymentGatewayClient2 = class extends PaymentGatewayClient {
    * @returns A complete `CreateQuoteRequest` body (no signature step needed)
    */
   async prepareQuoteRequest(params) {
-    const { quote_deadline, fulfillment_deadline } = resolveDeadlines(params, DEFAULT_QUOTE_DEADLINE_SECONDS);
-    const sourceChainId = params.sourceAsset.split("/")[0];
-    const destChainId = params.destinationAsset.split("/")[0];
+    assertPayableAccount(params.destinationAsset, params.destinationAccount);
+    if (!params.requestId) {
+      throw new Error(
+        "payment-gateway-client: requestId is required \u2014 it is the idempotency key the gateway dedups on; supply a stable id per logical quote-request and reuse it on retry"
+      );
+    }
+    const { quote_deadline, fulfillment_deadline } = resolveDeadlines(
+      params,
+      DEFAULT_QUOTE_DEADLINE_SECONDS
+    );
+    const source = parseAssetIdentifier(params.sourceAsset);
+    const destination = parseAssetIdentifier(params.destinationAsset);
+    const sourceChainId = source.chainId;
+    const destChainId = destination.chainId;
     const [sourceDefaults, destDefaults] = await Promise.all([
       this.fetchChainDefaults(sourceChainId),
       this.fetchChainDefaults(destChainId)
     ]);
     const contractOverrides = getChainAdapter(sourceChainId).resolveContractOverrides?.(sourceDefaults);
-    const requestId = params.requestId || `${params.requestIdPrefix || "quote-gw-sdk"}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
     return {
       version: PAYMENT_REQUEST_VERSION,
-      request_id: requestId,
+      request_id: params.requestId,
       source: {
-        asset_identifier: params.sourceAsset,
+        asset_identifier: source.normalized,
         account: params.depositor
       },
-      destination: [{
-        asset_identifier: params.destinationAsset,
-        account: params.destinationAccount
-      }],
+      destination: [
+        {
+          asset_identifier: destination.normalized,
+          account: params.destinationAccount
+        }
+      ],
       fulfillment_amount: params.fulfillmentAmount,
       max_source_amount: params.maxSourceAmount ?? defaultMaxSourceAmount(params.fulfillmentAmount),
       // Required + originator-supplied: the gateway injects no default and never
@@ -5961,21 +8355,159 @@ var PaymentGatewayClient2 = class extends PaymentGatewayClient {
   }
 };
 
+// src/cli/cli-input-error.ts
+var CliInputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CliInputError";
+  }
+};
+
 // src/cli/parse-seconds.ts
 function parseSeconds(optionName) {
   return (value) => {
     if (!/^-?\d+$/.test(value.trim())) {
-      throw new Error(`${optionName} must be an integer number of seconds`);
+      throw new CliInputError(`${optionName} must be an integer number of seconds`);
     }
     return Number(value);
   };
 }
 
+// src/cli/run-cli.ts
+function runCli(program2, ...parseArgs) {
+  try {
+    program2.parse(...parseArgs);
+  } catch (error) {
+    if (!(error instanceof CliInputError)) throw error;
+    console.error("\n\u274C Error:", error.message);
+    process.exit(1);
+  }
+}
+
 // src/version.ts
-var PACKAGE_VERSION = true ? "2.1.0" : "0.0.0-dev";
+var PACKAGE_VERSION = true ? "3.0.0" : "0.0.0-dev";
+
+// src/cli/payment-outcome.ts
+var EXIT_COMPLETED = 0;
+var EXIT_ERROR = 1;
+var EXIT_PENDING = 2;
+var EXIT_TERMINAL_FAILURE = 3;
+function describePaymentOutcome(input) {
+  const { status, paymentId, requestId, idempotentReplay, errorCode } = input;
+  const payment = paymentId ? `payment ${paymentId}` : "the payment";
+  const replay = idempotentReplay ? " This is the payment your earlier attempt created \u2014 nothing additional was charged." : "";
+  if (status === "completed") {
+    return {
+      exitCode: EXIT_COMPLETED,
+      summary: `completed: ${payment} settled.${replay}`
+    };
+  }
+  if (status === "failed" || status === "cancelled") {
+    const reason = errorCode ? ` (${errorCode})` : "";
+    return {
+      exitCode: EXIT_TERMINAL_FAILURE,
+      summary: `${status}: ${payment} ended without settling${reason}. This is final \u2014 re-submitting ${requestId ? `request id ${requestId}` : "the same request id"} returns this same failed payment, so a fresh attempt needs a NEW request id.`
+    };
+  }
+  const resubmit = requestId ? `request id ${requestId}` : "the same request id";
+  return {
+    exitCode: EXIT_PENDING,
+    summary: `pending: ${payment} was accepted and is still settling.${replay} To collect the result, keep checking its status, or re-submit ${resubmit}. Do not start a new payment under a different request id \u2014 that would pay twice.`
+  };
+}
+
+// src/cli/submit-and-report.ts
+async function submitAndReport(params) {
+  const {
+    client,
+    paymentRequest,
+    requestId,
+    wait = false,
+    waitSeconds = DEFAULT_WAIT_SECONDS,
+    pollIntervalMs,
+    writeOut = (line) => console.log(line),
+    writeErr = (line) => console.error(line)
+  } = params;
+  const response = await client.payments.submitPayment({ requestBody: paymentRequest });
+  let reported = response;
+  if (wait && response.payment_id && !isTerminalStatus(response.status)) {
+    writeErr(`waiting up to ${waitSeconds}s for ${response.payment_id} to settle...`);
+    const paymentId = response.payment_id;
+    const waited = await waitForTerminalStatus({
+      budgetMs: waitSeconds * 1e3,
+      intervalMs: pollIntervalMs,
+      fetchStatus: () => client.payments.getPaymentStatus({ paymentId }),
+      // A blip mid-settlement is the worst moment to give up, so report and keep checking.
+      onError: (err) => writeErr(
+        `status check failed, still waiting: ${err instanceof Error ? err.message : String(err)}`
+      )
+    });
+    if (waited.snapshot) {
+      reported = { ...reported, ...waited.snapshot };
+    }
+    if (waited.timedOut) {
+      writeErr(`still not settled after ${waitSeconds}s \u2014 reporting it as pending.`);
+    }
+  }
+  writeOut(JSON.stringify(reported, null, 2));
+  const outcome = {
+    status: reported.status,
+    paymentId: reported.payment_id,
+    requestId,
+    idempotentReplay: reported.idempotent_replay,
+    // Present when the gateway has recorded a reason — which includes the case where this
+    // submission was deduplicated onto a payment that had already failed.
+    errorCode: reported.error?.code
+  };
+  const { exitCode, summary } = describePaymentOutcome(outcome);
+  writeErr(summary);
+  return exitCode;
+}
+
+// src/cli/option-groups.ts
+var BUILD_ONLY_OPTIONS = [
+  "--request-id",
+  "--request-id-prefix",
+  "--quote-deadline-seconds",
+  "--fulfillment-deadline-seconds",
+  "--whitelistSettler",
+  "--provider",
+  "--solana-rpc-url"
+];
+function attributeNameOf(flag) {
+  return flag.replace(/^--/, "").replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
 
 // src/cli/send-payment.ts
+init_pinned_address();
+
+// src/cli/prompt-private-key.ts
 var readline = __toESM(require("readline"));
+async function promptPrivateKey() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  return new Promise((resolve2) => {
+    process.stderr.write("Enter private key (input hidden): ");
+    const originalWrite = process.stdout.write;
+    process.stdout.write = function(chunk, _encoding, _callback) {
+      if (chunk === "\n" || chunk === "\r\n") {
+        return originalWrite.apply(process.stdout, arguments);
+      }
+      return true;
+    };
+    rl.question("", (answer) => {
+      process.stdout.write = originalWrite;
+      process.stderr.write("\n");
+      rl.close();
+      resolve2(answer);
+    });
+    rl._writeToOutput = function() {
+    };
+  });
+}
 
 // src/cli/load-env.ts
 var import_dotenv = require("dotenv");
@@ -6004,7 +8536,64 @@ function loadTurnkeyConfigFromEnv() {
   };
 }
 var program = new import_commander.Command();
-program.name("send-payment").description("Send a cross-chain payment through Atum Payment Gateway").version(PACKAGE_VERSION).argument("<sender>", "Depositor address (e.g., 0xF0D0...)").argument("<amount>", "Amount to send (in smallest units, e.g., 100000 for 0.10 USDC)").argument("<sourceAsset>", "Source asset in CAIP-19 format").argument("<receiver>", "Destination account address").argument("<destinationAsset>", "Destination asset in CAIP-19 format").option("--gateway <url>", "Payment gateway URL (overrides GATEWAY_URL env; default: production-testnet)").option("--request-id <id>", "Idempotency key; seeds the on-chain deposit nonce. Reuse the same id to retry a payment safely. Omit to auto-generate a one-shot id.").option("--request-id-prefix <prefix>", "Custom request ID prefix (default: pmt-gw-cli)").option("--quote-deadline-seconds <n>", `Quote collection window in seconds (default: ${DEFAULT_PAYMENT_QUOTE_DEADLINE_SECONDS})`, parseSeconds("--quote-deadline-seconds")).option("--fulfillment-deadline-seconds <n>", `Settlement horizon in seconds (default: ${DEFAULT_FULFILLMENT_DEADLINE_SECONDS})`, parseSeconds("--fulfillment-deadline-seconds")).option("--whitelistSettler <did>", "Settler DID to whitelist (can be specified multiple times)", collect, []).option("--provider <raw|turnkey>", "Sender signing provider", "raw").option("--solana-rpc-url <url>", "Solana RPC used to read the cluster clock for issued_at (falls back to the SOLANA_RPC_URL env var, then the public endpoint for the cluster)").addHelpText("after", `
+program.name("send-payment").description(
+  [
+    "Send a cross-chain payment through Atum Payment Gateway.",
+    "",
+    "  Normally this prepares, signs and submits in one step. To have the payment",
+    "  approved before it is sent, split it in two: --prepare-only writes the signed",
+    "  request out, --submit sends one back in.",
+    "",
+    "  PREREQUISITE: paying from an EVM or Tron chain needs a one-off ERC-20/TRC-20",
+    "  approval of the source token for the Permit2 contract, made by the sender",
+    "  before this runs. Without it the payment is built and signed correctly and",
+    "  still fails to settle. Run `approve-permit2` to grant it; contract addresses",
+    "  are at the end of this help."
+  ].join("\n")
+).usage(
+  "[options] <sender> <amount> <sourceAsset> <receiver> <destinationAsset>\n   or: send-payment --submit <file> [options]"
+).version(PACKAGE_VERSION).argument("[sender]", "Depositor address (e.g., 0xF0D0...)").argument("[amount]", "Amount to send (in smallest units, e.g., 100000 for 0.10 USDC)").argument("[sourceAsset]", "Source asset in CAIP-19 format").argument("[receiver]", "Destination account address").argument("[destinationAsset]", "Destination asset in CAIP-19 format").option(
+  "--gateway <url>",
+  "Payment gateway URL (overrides GATEWAY_URL env; default: production-testnet)"
+).option(
+  "--request-id <id>",
+  "Idempotency key; seeds the on-chain deposit nonce. Re-run with the SAME id to re-attempt one payment \u2014 it resolves to the original instead of paying twice. Omitted, an id is generated and printed, which makes every bare re-run a SEPARATE payment (a second charge)."
+).option("--request-id-prefix <prefix>", "Custom request ID prefix (default: pmt-gw-cli)").option(
+  "--quote-deadline-seconds <n>",
+  `Quote collection window in seconds (default: ${DEFAULT_PAYMENT_QUOTE_DEADLINE_SECONDS})`,
+  parseSeconds("--quote-deadline-seconds")
+).option(
+  "--fulfillment-deadline-seconds <n>",
+  `Settlement horizon in seconds (default: ${DEFAULT_FULFILLMENT_DEADLINE_SECONDS})`,
+  parseSeconds("--fulfillment-deadline-seconds")
+).option(
+  "--whitelistSettler <did>",
+  "Settler DID to whitelist (can be specified multiple times)",
+  collect,
+  []
+).option("--provider <raw|turnkey>", "Sender signing provider", "raw").option(
+  "--wait",
+  "After submitting, keep checking the payment until it settles or fails instead of reporting it as still pending"
+).option(
+  "--wait-seconds <n>",
+  `How long --wait keeps checking (default: ${DEFAULT_WAIT_SECONDS}). A convenience bound only \u2014 giving up does not affect the payment`,
+  parseSeconds("--wait-seconds")
+).option(
+  "--solana-rpc-url <url>",
+  "Solana RPC used to read the cluster clock for issued_at (falls back to the SOLANA_RPC_URL env var, then the public endpoint for the cluster)"
+).addOption(
+  new import_commander.Option(
+    "--prepare-only",
+    "Build and sign the payment request, print it, and stop without submitting. For inspecting an authorization, or for review before paying. Send it later with --submit"
+  ).conflicts(["wait", "waitSeconds"])
+).addOption(
+  new import_commander.Option(
+    "--submit <file>",
+    "Submit a request built earlier by --prepare-only, instead of building one. Signs nothing and needs no private key. Use - to read stdin"
+  ).conflicts(["prepareOnly", ...BUILD_ONLY_OPTIONS.map(attributeNameOf)])
+).addHelpText(
+  "after",
+  `
 CAIP-19 Examples:
   EVM ERC20:   eip155:42161/erc20:0xaf88d065e77c8cC2239327C5EDb3A432268e5831
   Tron TRC20:  tron:shasta/trc20:TG3XXyExBkPp9nzdajDZsozEu4BkaSJozs
@@ -6019,17 +8608,97 @@ Signing (default --provider raw):
 Output:
   PaymentRequest JSON  \u2192 stderr (for debugging/logging)
   PaymentResponse JSON \u2192 stdout (for parsing/automation)
+  Outcome summary      \u2192 stderr
+
+With --wait the JSON is printed once the wait ends, reporting the payment's state
+as of the last check rather than as of the submit.
+
+--prepare-only:
+  Builds and signs the request, prints it to stdout, and stops. Nothing is
+  submitted and no payment exists. The document printed is exactly what would
+  have been POSTed, so you can inspect it, have it reviewed, then send it with
+  \`send-payment --submit <file>\` (or pipe it:
+  \`send-payment --prepare-only ... | send-payment --submit -\`).
+
+  It still contacts the gateway, which is where the corridor addresses come from,
+  so it is not an offline mode.
+
+  The file it writes is a signed authorization, not a draft. Anyone holding it can
+  send it with --submit, which needs no key. Treat it like a signed cheque: keep it
+  where you would keep a credential, and delete it once the payment is sent or the
+  request is abandoned.
+
+  Re-preparing with the same --request-id targets the same payment: the deposit nonce
+  comes from the id, so it cannot pay twice. It does not reproduce the same bytes \u2014
+  the deadlines are stamped from the clock and the signature covers them.
+
+  Intending to submit later? The document is only submittable while its quote
+  window is open, and the default is ${DEFAULT_PAYMENT_QUOTE_DEADLINE_SECONDS}s, so widen it with
+  --quote-deadline-seconds to leave room to read it.
+
+  Widen it by tens of seconds, not minutes. The window is also the auction: the
+  gateway waits it out before choosing a settler, and settler quotes expire on
+  their own, so an over-long window ends in QUOTES_EXPIRED \u2014 which is terminal,
+  and a fresh attempt then needs a NEW --request-id.
+
+Exit codes:
+  0  completed \u2014 settled
+  2  pending   \u2014 accepted, no result yet; follow it with payment-status <payment_id>,
+                 or use --wait
+  3  failed    \u2014 terminal; a fresh attempt needs a NEW --request-id
+  1  no outcome obtained (rejected, unreachable gateway, bad arguments)
+
+So \`send-payment ... && <next step>\` runs the next step only for a settled payment.
+
+The table above describes a SUBMITTED payment, so it does not apply to
+--prepare-only: there, 0 means the request was built and signed, not that anything
+was paid. Do not chain a payment-conditional step off a --prepare-only run.
+
+Exit 1 means unknown, not "nothing happened" \u2014 a request that timed out may still
+have been accepted, and you may have no payment_id to look up. Re-run with the same
+--request-id, which resolves to the payment if one was created and creates it if not.
 
 After submission, you can check payment status at eg http://PAYMENT_GW/v1/payments/PAYMENT_ID/status
 
-NOTE: Payments from EVM chains require prior ERC-20 approval on the source
-token for the Permit2 contract (0x000000000022D473030F116dDEE9F6B43aC78BA3 on
-virtually all EVM chains). (And the same applies for Tron/TRC-20, with a
-Permit2 address of TJhMXTHQHeQyMD7TcKQFqAePNgG4b31H9m on mainnet or
-TPUqJPASUn1zLvbLBgRZ5pBYrx7WSe5ahp on Shasta)`).action(async (sender, amount, sourceAsset, receiver, destinationAsset, options) => {
+Permit2 contract addresses, for the approval named under PREREQUISITE above:
+  EVM:          0x000000000022D473030F116dDEE9F6B43aC78BA3 (virtually all chains)
+  Tron mainnet: TJhMXTHQHeQyMD7TcKQFqAePNgG4b31H9m
+  Tron Shasta:  TPUqJPASUn1zLvbLBgRZ5pBYrx7WSe5ahp`
+).action(async (sender, amount, sourceAsset, receiver, destinationAsset, options) => {
   let requestId;
+  let submittedRequest;
   try {
-    const sourceChainId = sourceAsset.split("/")[0];
+    const corridor = [sender, amount, sourceAsset, receiver, destinationAsset];
+    const supplied = corridor.filter((value) => value !== void 0).length;
+    if (options.submit && supplied > 0) {
+      throw new Error(
+        "--submit sends a request that was already built, so the corridor arguments do not apply. Drop them, or drop --submit to build a new payment."
+      );
+    }
+    if (!options.submit && supplied < corridor.length) {
+      throw new Error(
+        `send-payment needs five arguments (sender, amount, sourceAsset, receiver, destinationAsset), or --submit <file> to send a request prepared earlier. Got ${supplied}.`
+      );
+    }
+    if (options.submit) {
+      const prepared = await readPaymentRequest(options.submit);
+      submittedRequest = prepared;
+      requestId = prepared.request_id;
+      warnIfQuoteWindowClosed(prepared);
+      console.error(
+        `submitting request_id ${requestId} (quote_deadline ${prepared.quote_deadline})`
+      );
+      const submittedCode = await submitAndReport({
+        client: new PaymentGatewayClient2({ BASE: options.gateway }),
+        paymentRequest: prepared,
+        requestId,
+        wait: options.wait,
+        waitSeconds: options.waitSeconds
+      });
+      process.exit(submittedCode);
+    }
+    requirePinnedSender(sender);
+    const sourceChainId = assetChainId(sourceAsset);
     let privateKey = "";
     let signer;
     if (options.provider === "turnkey") {
@@ -6040,7 +8709,11 @@ TPUqJPASUn1zLvbLBgRZ5pBYrx7WSe5ahp on Shasta)`).action(async (sender, amount, so
       });
     } else if (options.provider === "raw") {
       privateKey = process.env.PRIVATE_KEY || await promptPrivateKey();
-      signer = createSenderSigner(sourceChainId, { provider: "raw", privateKey, pinnedAddress: sender });
+      signer = createSenderSigner(sourceChainId, {
+        provider: "raw",
+        privateKey,
+        pinnedAddress: sender
+      });
     } else {
       throw new Error(`Unknown --provider '${options.provider}' (expected 'raw' or 'turnkey')`);
     }
@@ -6068,55 +8741,103 @@ TPUqJPASUn1zLvbLBgRZ5pBYrx7WSe5ahp on Shasta)`).action(async (sender, amount, so
         delegate_signer: delegateSigner
       };
     }
+    if (options.prepareOnly) {
+      console.log(JSON.stringify(paymentRequest, null, 2));
+      console.error(
+        `request_id: ${requestId}  (re-preparing with this id targets the same payment, but stamps fresh deadlines and a fresh signature, so the document itself will differ)`
+      );
+      console.error(
+        `quote_deadline: ${paymentRequest.quote_deadline}  (the gateway refuses this document after that instant; pass --quote-deadline-seconds to widen it)`
+      );
+      console.error(
+        "prepared: nothing was submitted and no payment exists. Send it with `send-payment --submit <file>`."
+      );
+      console.error(
+        "KEEP IT SAFE: this file is a signed authorization for this payment, not a draft. Anyone holding it can send it, with no key. Delete it once the payment is sent or the request is abandoned."
+      );
+      process.exit(EXIT_COMPLETED);
+    }
     console.error(JSON.stringify(paymentRequest, null, 2));
-    console.error(`request_id: ${requestId}  (re-run with --request-id ${requestId} to retry this same payment)`);
-    const response = await client.payments.submitPayment({
-      requestBody: paymentRequest
+    console.error(
+      `request_id: ${requestId}  (re-run with --request-id ${requestId} to retry this same payment)`
+    );
+    const exitCode = await submitAndReport({
+      client,
+      paymentRequest,
+      requestId,
+      wait: options.wait,
+      waitSeconds: options.waitSeconds
     });
-    console.log(JSON.stringify(response, null, 2));
-    process.exit(0);
+    process.exit(exitCode);
   } catch (error) {
     if (error instanceof ApiError && error.body) {
       console.log(JSON.stringify(error.body, null, 2));
     } else {
       console.error("\n\u274C Error:", error instanceof Error ? error.message : String(error));
-      if (error instanceof Error && error.availableDefaults) {
-        console.error("\n\u{1F4CB} Available gateway defaults:");
-        console.error(JSON.stringify(error.availableDefaults, null, 2));
-      }
     }
     if (requestId) {
-      console.error(`request_id: ${requestId}  (re-run with --request-id ${requestId} to retry this same payment)`);
+      const windowStillOpen = submittedRequest !== void 0 && quoteWindowOpen(submittedRequest);
+      console.error(
+        options.submit ? windowStillOpen ? `request_id: ${requestId}  (the quote window on this file may still be open, so sending it again is the first thing to try)` : `request_id: ${requestId}  (this file's quote window has closed, so sending it again will be refused. Ask whoever holds the key to prepare a fresh request with --request-id ${requestId}: that targets this same payment, so it cannot pay twice)` : `request_id: ${requestId}  (re-run with --request-id ${requestId} to retry this same payment)`
+      );
     }
-    process.exit(1);
+    process.exit(EXIT_ERROR);
   }
 });
-async function promptPrivateKey() {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: true
-  });
-  return new Promise((resolve2) => {
-    process.stderr.write("Enter private key (input hidden): ");
-    const originalWrite = process.stdout.write;
-    process.stdout.write = function(chunk, encoding, callback) {
-      if (chunk === "\n" || chunk === "\r\n") {
-        return originalWrite.apply(process.stdout, arguments);
-      }
-      return true;
-    };
-    rl.question("", (answer) => {
-      process.stdout.write = originalWrite;
-      process.stderr.write("\n");
-      rl.close();
-      resolve2(answer);
-    });
-    rl._writeToOutput = function() {
-    };
-  });
+async function readPaymentRequest(file) {
+  if (file === "-" && process.stdin.isTTY) {
+    throw new Error("--submit - reads stdin, but nothing is piped in. Pass a file path instead");
+  }
+  const raw = file === "-" ? await readStdin() : (0, import_fs.readFileSync)(file, "utf8");
+  if (raw.trim() === "") {
+    throw new Error(
+      file === "-" ? "nothing arrived on stdin. Pipe a prepared request in, or pass a file path instead" : `${file} is empty`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `${file === "-" ? "stdin" : file} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`${file === "-" ? "stdin" : file} does not hold a PaymentRequest object`);
+  }
+  const request2 = parsed;
+  if (!request2.request_id) {
+    throw new Error(
+      "this does not look like a PaymentRequest: no request_id. Produce one with `send-payment --prepare-only`"
+    );
+  }
+  const signature = request2.sender_auth?.signed_messages?.[0]?.signature;
+  if (!signature) {
+    throw new Error(
+      "this request carries no sender_auth signature, so it cannot be submitted. `send-payment --prepare-only` signs the request it prints; a request built with the SDK needs signPaymentRequest before it is submittable"
+    );
+  }
+  return request2;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function quoteWindowOpen(request2) {
+  const deadline = Date.parse(request2.quote_deadline ?? "");
+  return Number.isNaN(deadline) || deadline > Date.now();
+}
+function warnIfQuoteWindowClosed(request2) {
+  if (quoteWindowOpen(request2)) return;
+  console.error(
+    `warning: this request's quote_deadline (${request2.quote_deadline}) has passed by this machine's clock, and the gateway refuses a closed quote window. Sending anyway, since the gateway goes by its own clock. If it rejects this, prepare a fresh request \u2014 and give the next one a longer --quote-deadline-seconds, which is an option of the form that builds a request, not of --submit.`
+  );
 }
-program.parse();
+runCli(program);
 /*! Bundled license information:
 
 @noble/hashes/utils.js: