@atumlabs/payment-gateway-client 1.0.1

package/dist/cli/quote-status.js

@@ -0,0 +1,3125 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../contracts/evm/escrow-encoding/typescript/dist/payment-id.js
+var require_payment_id = __commonJS({
+  "../contracts/evm/escrow-encoding/typescript/dist/payment-id.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.computePaymentId = computePaymentId;
+    exports2.computePaymentIdV2 = computePaymentIdV2;
+    var ethers_1 = require("ethers");
+    function computePaymentId(depositor, signature) {
+      const abiCoder = ethers_1.ethers.AbiCoder.defaultAbiCoder();
+      const encoded = abiCoder.encode(["address", "bytes"], [depositor, signature]);
+      return ethers_1.ethers.keccak256(encoded);
+    }
+    function computePaymentIdV2(depositor, signature, nonce) {
+      const abiCoder = ethers_1.ethers.AbiCoder.defaultAbiCoder();
+      const encoded = abiCoder.encode(["address", "bytes", "uint256"], [depositor, signature, nonce]);
+      return ethers_1.ethers.keccak256(encoded);
+    }
+  }
+});
+
+// ../contracts/evm/escrow-encoding/typescript/dist/nonce-generator.js
+var require_nonce_generator = __commonJS({
+  "../contracts/evm/escrow-encoding/typescript/dist/nonce-generator.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.generateNonce = generateNonce2;
+    var ethers_1 = require("ethers");
+    function generateNonce2() {
+      return ethers_1.ethers.hexlify(ethers_1.ethers.randomBytes(32));
+    }
+  }
+});
+
+// ../contracts/evm/escrow-encoding/typescript/dist/permit-types.js
+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.createPermit2Domain = createPermit2Domain;
+    exports2.createEscrowDomain = createEscrowDomain;
+    exports2.PERMIT_WITNESS_TYPES = {
+      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: "requestId", type: "bytes32" },
+        { name: "reserver", type: "address" },
+        { name: "releaser", type: "address" }
+      ]
+    };
+    exports2.PERMIT_WITNESS_TYPES_V2 = {
+      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: "reserver", type: "address" },
+        { name: "releaser", type: "address" }
+      ]
+    };
+    function createPermit2Domain(chainId, verifyingContract) {
+      return {
+        name: "Permit2",
+        chainId,
+        verifyingContract
+      };
+    }
+    function createEscrowDomain(chainId, verifyingContract) {
+      return {
+        name: "Escrow",
+        version: "3",
+        chainId,
+        verifyingContract
+      };
+    }
+    exports2.RESERVE_WITNESS_TYPES = {
+      ReserveWitness: [
+        { name: "paymentId", type: "bytes32" },
+        { name: "settler", type: "address" }
+      ]
+    };
+    exports2.RELEASE_WITNESS_TYPES = {
+      ReleaseWitness: [
+        { name: "paymentId", 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 = {
+      RefundWitness: [
+        { name: "paymentId", 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" },
+              { name: "deadline", type: "uint256" }
+            ]
+          },
+          { name: "depositor", type: "address" },
+          {
+            name: "witness",
+            type: "tuple",
+            components: [
+              { name: "requestId", type: "bytes32" },
+              { name: "reserver", type: "address" },
+              { name: "releaser", type: "address" }
+            ]
+          },
+          { name: "signature", type: "bytes" }
+        ],
+        outputs: [{ name: "depositId", type: "bytes32" }],
+        stateMutability: "nonpayable"
+      },
+      {
+        type: "function",
+        name: "refund",
+        inputs: [
+          {
+            name: "witness",
+            type: "tuple",
+            components: [
+              { name: "depositId", type: "bytes32" },
+              { name: "deadline", type: "uint256" }
+            ]
+          },
+          { name: "signature", type: "bytes" }
+        ],
+        outputs: [],
+        stateMutability: "nonpayable"
+      },
+      {
+        type: "function",
+        name: "getDepositInfo",
+        inputs: [{ name: "depositId", type: "bytes32" }],
+        outputs: [
+          {
+            name: "",
+            type: "tuple",
+            components: [
+              { name: "depositor", type: "address" },
+              { name: "token", type: "address" },
+              { name: "amount", type: "uint256" },
+              { name: "reserver", type: "address" },
+              { name: "releaser", type: "address" },
+              { name: "settler", type: "address" }
+            ]
+          }
+        ],
+        stateMutability: "view"
+      },
+      {
+        type: "function",
+        name: "i_permit2",
+        inputs: [],
+        outputs: [{ name: "", type: "address" }],
+        stateMutability: "view"
+      }
+    ];
+    exports2.ESCROW_V3_ABI_JSON = [
+      {
+        type: "function",
+        name: "deposit",
+        inputs: [
+          {
+            name: "depositInput",
+            type: "tuple",
+            components: [
+              {
+                name: "permit",
+                type: "tuple",
+                components: [
+                  {
+                    name: "permitted",
+                    type: "tuple",
+                    components: [
+                      { name: "token", type: "address" },
+                      { name: "amount", type: "uint256" }
+                    ]
+                  },
+                  { name: "nonce", type: "uint256" },
+                  { name: "deadline", type: "uint256" }
+                ]
+              },
+              { name: "depositor", type: "address" },
+              {
+                name: "depositWitness",
+                type: "tuple",
+                components: [
+                  { name: "reserver", type: "address" },
+                  { name: "releaser", type: "address" }
+                ]
+              },
+              { name: "depositSignature", type: "bytes" },
+              {
+                name: "reserveWitness",
+                type: "tuple",
+                components: [
+                  { name: "paymentId", type: "bytes32" },
+                  { name: "settler", type: "address" }
+                ]
+              },
+              { name: "reserveSignature", type: "bytes" }
+            ]
+          }
+        ],
+        outputs: [{ name: "paymentId", type: "bytes32" }],
+        stateMutability: "nonpayable"
+      },
+      {
+        type: "function",
+        name: "refund",
+        inputs: [
+          {
+            name: "refundInput",
+            type: "tuple",
+            components: [
+              {
+                name: "refundWitness",
+                type: "tuple",
+                components: [
+                  { name: "paymentId", 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" }
+                ]
+              },
+              { name: "refundSignature", type: "bytes" }
+            ]
+          }
+        ],
+        outputs: [],
+        stateMutability: "nonpayable"
+      },
+      {
+        type: "function",
+        name: "getDepositHash",
+        inputs: [{ name: "paymentId", type: "bytes32" }],
+        outputs: [{ name: "", type: "bytes32" }],
+        stateMutability: "view"
+      },
+      {
+        type: "function",
+        name: "i_permit2",
+        inputs: [],
+        outputs: [{ name: "", type: "address" }],
+        stateMutability: "view"
+      }
+    ];
+    exports2.ESCROW_V2_ABI_JSON = exports2.ESCROW_V3_ABI_JSON;
+  }
+});
+
+// ../contracts/evm/escrow-encoding/typescript/dist/reserve-encoder.js
+var require_reserve_encoder = __commonJS({
+  "../contracts/evm/escrow-encoding/typescript/dist/reserve-encoder.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.computeReserveDigest = computeReserveDigest;
+    var ethers_1 = require("ethers");
+    var permit_types_1 = require_permit_types();
+    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, {
+        paymentId: input.paymentId,
+        settler: input.settler
+      });
+    }
+  }
+});
+
+// ../contracts/evm/escrow-encoding/typescript/dist/deposit-encoder.js
+var require_deposit_encoder = __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.createPermitWitnessTransferFromPrehash = createPermitWitnessTransferFromPrehash2;
+    exports2.hashPermitWitnessTransferFrom = hashPermitWitnessTransferFrom2;
+    var ethers_1 = require("ethers");
+    var permit_types_1 = require_permit_types();
+    exports2.PERMIT2_CONTRACT_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+    function createPermitWitnessTransferFromPrehash2(params) {
+      return {
+        types: permit_types_1.PERMIT_WITNESS_TYPES_V2,
+        primaryType: "PermitWitnessTransferFrom",
+        domain: {
+          name: "Permit2",
+          chainId: `0x${params.chainId.toString(16)}`,
+          verifyingContract: params.verifyingContract
+        },
+        message: {
+          permitted: {
+            token: params.token,
+            amount: params.amount
+          },
+          spender: params.spender,
+          nonce: params.nonce.toString(),
+          deadline: params.deadline.toString(),
+          witness: {
+            reserver: params.reserver,
+            releaser: params.releaser
+          }
+        }
+      };
+    }
+    function hashPermitWitnessTransferFrom2(prehash) {
+      return ethers_1.TypedDataEncoder.hash(prehash.domain, prehash.types, prehash.message);
+    }
+  }
+});
+
+// ../contracts/evm/escrow-encoding/typescript/dist/index.js
+var require_dist = __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;
+    var payment_id_1 = require_payment_id();
+    Object.defineProperty(exports2, "computePaymentId", { enumerable: true, get: function() {
+      return payment_id_1.computePaymentId;
+    } });
+    Object.defineProperty(exports2, "computePaymentIdV2", { enumerable: true, get: function() {
+      return payment_id_1.computePaymentIdV2;
+    } });
+    var nonce_generator_1 = require_nonce_generator();
+    Object.defineProperty(exports2, "generateNonce", { enumerable: true, get: function() {
+      return nonce_generator_1.generateNonce;
+    } });
+    var permit_types_1 = require_permit_types();
+    Object.defineProperty(exports2, "PERMIT_WITNESS_TYPES", { enumerable: true, get: function() {
+      return permit_types_1.PERMIT_WITNESS_TYPES;
+    } });
+    Object.defineProperty(exports2, "PERMIT_WITNESS_TYPES_V2", { enumerable: true, get: function() {
+      return permit_types_1.PERMIT_WITNESS_TYPES_V2;
+    } });
+    Object.defineProperty(exports2, "createPermit2Domain", { enumerable: true, get: function() {
+      return permit_types_1.createPermit2Domain;
+    } });
+    Object.defineProperty(exports2, "createEscrowDomain", { enumerable: true, get: function() {
+      return permit_types_1.createEscrowDomain;
+    } });
+    Object.defineProperty(exports2, "RESERVE_WITNESS_TYPES", { enumerable: true, get: function() {
+      return permit_types_1.RESERVE_WITNESS_TYPES;
+    } });
+    Object.defineProperty(exports2, "RELEASE_WITNESS_TYPES", { enumerable: true, get: function() {
+      return permit_types_1.RELEASE_WITNESS_TYPES;
+    } });
+    Object.defineProperty(exports2, "REFUND_WITNESS_TYPES", { enumerable: true, get: function() {
+      return permit_types_1.REFUND_WITNESS_TYPES;
+    } });
+    var escrow_abi_1 = require_escrow_abi();
+    Object.defineProperty(exports2, "ESCROW_ABI", { enumerable: true, get: function() {
+      return escrow_abi_1.ESCROW_ABI;
+    } });
+    Object.defineProperty(exports2, "ESCROW_ABI_JSON", { enumerable: true, get: function() {
+      return escrow_abi_1.ESCROW_ABI_JSON;
+    } });
+    Object.defineProperty(exports2, "ESCROW_V2_ABI_JSON", { enumerable: true, get: function() {
+      return escrow_abi_1.ESCROW_V2_ABI_JSON;
+    } });
+    Object.defineProperty(exports2, "ESCROW_V3_ABI_JSON", { enumerable: true, get: function() {
+      return escrow_abi_1.ESCROW_V3_ABI_JSON;
+    } });
+    var reserve_encoder_1 = require_reserve_encoder();
+    Object.defineProperty(exports2, "computeReserveDigest", { enumerable: true, get: function() {
+      return reserve_encoder_1.computeReserveDigest;
+    } });
+    var deposit_encoder_1 = require_deposit_encoder();
+    Object.defineProperty(exports2, "createPermitWitnessTransferFromPrehash", { enumerable: true, get: function() {
+      return deposit_encoder_1.createPermitWitnessTransferFromPrehash;
+    } });
+    Object.defineProperty(exports2, "hashPermitWitnessTransferFrom", { enumerable: true, get: function() {
+      return deposit_encoder_1.hashPermitWitnessTransferFrom;
+    } });
+    Object.defineProperty(exports2, "PERMIT2_CONTRACT_ADDRESS", { enumerable: true, get: function() {
+      return deposit_encoder_1.PERMIT2_CONTRACT_ADDRESS;
+    } });
+  }
+});
+
+// ../contracts/tvm/escrow-encoding/typescript/dist/chain-id.js
+var require_chain_id = __commonJS({
+  "../contracts/tvm/escrow-encoding/typescript/dist/chain-id.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.maskChainId = maskChainId2;
+    function maskChainId2(chainId) {
+      return (chainId & 4294967295) >>> 0;
+    }
+  }
+});
+
+// ../contracts/tvm/escrow-encoding/typescript/dist/tron-address.js
+var require_tron_address = __commonJS({
+  "../contracts/tvm/escrow-encoding/typescript/dist/tron-address.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.base58ToHex = base58ToHex2;
+    exports2.normalizeAddress = normalizeAddress2;
+    var ethers_1 = require("ethers");
+    var bs58_1 = __importDefault(require("bs58"));
+    var TVM_MAINNET_PREFIX = "41";
+    function base58ToHex2(base58Address) {
+      if (!base58Address || !base58Address.startsWith("T")) {
+        throw new Error(`Invalid Tron base58 address: ${base58Address}`);
+      }
+      const decoded = bs58_1.default.decode(base58Address);
+      if (decoded.length !== 25) {
+        throw new Error(`Invalid Tron base58 length (expected 25 bytes): ${base58Address}`);
+      }
+      const payload = decoded.slice(0, 21);
+      const checksum = (0, ethers_1.hexlify)(decoded.slice(21)).slice(2);
+      const computed = (0, ethers_1.sha256)((0, ethers_1.sha256)(payload)).slice(2, 10);
+      if (checksum !== computed) {
+        throw new Error(`Invalid Tron base58 checksum: ${base58Address}`);
+      }
+      return (0, ethers_1.hexlify)(payload).slice(2);
+    }
+    function normalizeAddress2(address) {
+      if (!address) {
+        throw new Error("Empty address");
+      }
+      let hexAddress = address;
+      if (address.startsWith("T")) {
+        hexAddress = base58ToHex2(address);
+      }
+      hexAddress = hexAddress.replace(/^0x/, "");
+      if (hexAddress.startsWith(TVM_MAINNET_PREFIX)) {
+        hexAddress = hexAddress.substring(2);
+      }
+      if (hexAddress.length !== 40) {
+        throw new Error(`Invalid address length: expected 40 chars, got ${hexAddress.length}`);
+      }
+      if (!/^[0-9a-fA-F]{40}$/.test(hexAddress)) {
+        throw new Error("Invalid hex address format");
+      }
+      return "0x" + hexAddress.toLowerCase();
+    }
+  }
+});
+
+// ../contracts/tvm/escrow-encoding/typescript/dist/reserve-encoder.js
+var require_reserve_encoder2 = __commonJS({
+  "../contracts/tvm/escrow-encoding/typescript/dist/reserve-encoder.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.computeReserveDigest = computeReserveDigest;
+    var ethers_1 = require("ethers");
+    var chain_id_1 = require_chain_id();
+    var RESERVE_WITNESS_TYPES = {
+      ReserveWitness: [
+        { name: "paymentId", type: "bytes32" },
+        { name: "settler", type: "address" }
+      ]
+    };
+    function computeReserveDigest(input) {
+      const domain = {
+        name: "Escrow",
+        version: "3",
+        chainId: (0, chain_id_1.maskChainId)(input.chainId),
+        verifyingContract: input.escrowContract
+      };
+      return ethers_1.TypedDataEncoder.hash(domain, RESERVE_WITNESS_TYPES, {
+        paymentId: input.paymentId,
+        settler: input.settler
+      });
+    }
+  }
+});
+
+// ../contracts/tvm/escrow-encoding/typescript/dist/payment-id.js
+var require_payment_id2 = __commonJS({
+  "../contracts/tvm/escrow-encoding/typescript/dist/payment-id.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.computePaymentId = computePaymentId;
+    var ethers_1 = require("ethers");
+    var tron_address_1 = require_tron_address();
+    function computePaymentId(depositor, signature, nonce) {
+      if (!/^[0-9]+$/.test(nonce)) {
+        throw new Error(`invalid nonce (expected base-10 decimal): ${nonce}`);
+      }
+      const encoded = ethers_1.AbiCoder.defaultAbiCoder().encode(["address", "bytes", "uint256"], [(0, tron_address_1.normalizeAddress)(depositor), signature, nonce]);
+      return (0, ethers_1.keccak256)(encoded);
+    }
+  }
+});
+
+// ../contracts/tvm/escrow-encoding/typescript/dist/deposit-encoder.js
+var require_deposit_encoder2 = __commonJS({
+  "../contracts/tvm/escrow-encoding/typescript/dist/deposit-encoder.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createTvmPermitWitnessTransferFromPrehash = createTvmPermitWitnessTransferFromPrehash2;
+    exports2.hashTvmPermitWitnessTransferFrom = hashTvmPermitWitnessTransferFrom2;
+    var ethers_1 = require("ethers");
+    var chain_id_1 = require_chain_id();
+    var tron_address_1 = require_tron_address();
+    var PERMIT_WITNESS_TYPES_V2 = {
+      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: "reserver", type: "address" },
+        { name: "releaser", type: "address" }
+      ]
+    };
+    function createTvmPermitWitnessTransferFromPrehash2(params) {
+      const maskedChainId = (0, chain_id_1.maskChainId)(params.chainId);
+      return {
+        types: PERMIT_WITNESS_TYPES_V2,
+        primaryType: "PermitWitnessTransferFrom",
+        domain: {
+          name: "Permit2",
+          chainId: `0x${maskedChainId.toString(16)}`,
+          verifyingContract: (0, tron_address_1.normalizeAddress)(params.permit2Address)
+        },
+        message: {
+          permitted: {
+            token: (0, tron_address_1.normalizeAddress)(params.tokenAddress),
+            amount: params.amount
+          },
+          spender: (0, tron_address_1.normalizeAddress)(params.spenderAddress),
+          nonce: params.nonce.toString(),
+          deadline: params.deadline.toString(),
+          witness: {
+            reserver: (0, tron_address_1.normalizeAddress)(params.reserverAddress),
+            releaser: (0, tron_address_1.normalizeAddress)(params.releaserAddress)
+          }
+        }
+      };
+    }
+    function hashTvmPermitWitnessTransferFrom2(prehash) {
+      return ethers_1.TypedDataEncoder.hash(prehash.domain, prehash.types, prehash.message);
+    }
+  }
+});
+
+// ../contracts/tvm/escrow-encoding/typescript/dist/index.js
+var require_dist2 = __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;
+    var chain_id_1 = require_chain_id();
+    Object.defineProperty(exports2, "maskChainId", { enumerable: true, get: function() {
+      return chain_id_1.maskChainId;
+    } });
+    var tron_address_1 = require_tron_address();
+    Object.defineProperty(exports2, "base58ToHex", { enumerable: true, get: function() {
+      return tron_address_1.base58ToHex;
+    } });
+    Object.defineProperty(exports2, "normalizeAddress", { enumerable: true, get: function() {
+      return tron_address_1.normalizeAddress;
+    } });
+    var reserve_encoder_1 = require_reserve_encoder2();
+    Object.defineProperty(exports2, "computeReserveDigest", { enumerable: true, get: function() {
+      return reserve_encoder_1.computeReserveDigest;
+    } });
+    var payment_id_1 = require_payment_id2();
+    Object.defineProperty(exports2, "computePaymentId", { enumerable: true, get: function() {
+      return payment_id_1.computePaymentId;
+    } });
+    var deposit_encoder_1 = require_deposit_encoder2();
+    Object.defineProperty(exports2, "createTvmPermitWitnessTransferFromPrehash", { enumerable: true, get: function() {
+      return deposit_encoder_1.createTvmPermitWitnessTransferFromPrehash;
+    } });
+    Object.defineProperty(exports2, "hashTvmPermitWitnessTransferFrom", { enumerable: true, get: function() {
+      return deposit_encoder_1.hashTvmPermitWitnessTransferFrom;
+    } });
+  }
+});
+
+// ../contracts/svm/escrow-encoding/typescript/dist/errors.js
+var require_errors = __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;
+    var EncodingError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "EncodingError";
+      }
+    };
+    exports2.EncodingError = EncodingError;
+    var ZeroPaymentIdError = class extends EncodingError {
+      constructor() {
+        super("payment ID cannot be zero");
+        this.name = "ZeroPaymentIdError";
+      }
+    };
+    exports2.ZeroPaymentIdError = ZeroPaymentIdError;
+    var ZeroDepositorError = class extends EncodingError {
+      constructor() {
+        super("depositor cannot be zero");
+        this.name = "ZeroDepositorError";
+      }
+    };
+    exports2.ZeroDepositorError = ZeroDepositorError;
+    var ZeroMintError = class extends EncodingError {
+      constructor() {
+        super("mint cannot be zero");
+        this.name = "ZeroMintError";
+      }
+    };
+    exports2.ZeroMintError = ZeroMintError;
+    var ZeroAmountError = class extends EncodingError {
+      constructor() {
+        super("amount cannot be zero");
+        this.name = "ZeroAmountError";
+      }
+    };
+    exports2.ZeroAmountError = ZeroAmountError;
+    var ZeroReserverError = class extends EncodingError {
+      constructor() {
+        super("reserver cannot be zero");
+        this.name = "ZeroReserverError";
+      }
+    };
+    exports2.ZeroReserverError = ZeroReserverError;
+    var ZeroReleaserError = class extends EncodingError {
+      constructor() {
+        super("releaser cannot be zero");
+        this.name = "ZeroReleaserError";
+      }
+    };
+    exports2.ZeroReleaserError = ZeroReleaserError;
+    var ZeroRecipientError = class extends EncodingError {
+      constructor() {
+        super("recipient cannot be zero");
+        this.name = "ZeroRecipientError";
+      }
+    };
+    exports2.ZeroRecipientError = ZeroRecipientError;
+    var ZeroDepositHashError = class extends EncodingError {
+      constructor() {
+        super("deposit hash cannot be zero");
+        this.name = "ZeroDepositHashError";
+      }
+    };
+    exports2.ZeroDepositHashError = ZeroDepositHashError;
+    var InvalidPubkeyLengthError = class extends EncodingError {
+      constructor() {
+        super("invalid pubkey length: expected 32 bytes");
+        this.name = "InvalidPubkeyLengthError";
+      }
+    };
+    exports2.InvalidPubkeyLengthError = InvalidPubkeyLengthError;
+    var InvalidBase58Error = class extends EncodingError {
+      constructor() {
+        super("invalid base58 encoding");
+        this.name = "InvalidBase58Error";
+      }
+    };
+    exports2.InvalidBase58Error = InvalidBase58Error;
+    var InvalidHexError = class extends EncodingError {
+      constructor() {
+        super("invalid hex encoding");
+        this.name = "InvalidHexError";
+      }
+    };
+    exports2.InvalidHexError = InvalidHexError;
+  }
+});
+
+// ../contracts/svm/escrow-encoding/typescript/dist/pubkey.js
+var require_pubkey = __commonJS({
+  "../contracts/svm/escrow-encoding/typescript/dist/pubkey.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.Pubkey = void 0;
+    var bs58_1 = __importDefault(require("bs58"));
+    var errors_1 = require_errors();
+    var Pubkey3 = class _Pubkey {
+      constructor(data) {
+        if (data.length !== 32) {
+          throw new errors_1.InvalidPubkeyLengthError();
+        }
+        this.data = data;
+      }
+      /**
+       * Creates a Pubkey from a Base58-encoded string.
+       * This is the standard format for Solana public keys.
+       */
+      static fromBase58(s) {
+        try {
+          const decoded = bs58_1.default.decode(s);
+          if (decoded.length !== 32) {
+            throw new errors_1.InvalidPubkeyLengthError();
+          }
+          return new _Pubkey(decoded);
+        } catch (e) {
+          if (e instanceof errors_1.InvalidPubkeyLengthError) {
+            throw e;
+          }
+          throw new errors_1.InvalidBase58Error();
+        }
+      }
+      /**
+       * Creates a Pubkey from a hex-encoded string.
+       * Accepts with or without "0x" prefix.
+       */
+      static fromHex(s) {
+        let hex = s;
+        if (hex.startsWith("0x") || hex.startsWith("0X")) {
+          hex = hex.slice(2);
+        }
+        if (hex.length !== 64) {
+          throw new errors_1.InvalidPubkeyLengthError();
+        }
+        try {
+          const bytes = new Uint8Array(32);
+          for (let i = 0; i < 32; i++) {
+            bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+            if (isNaN(bytes[i])) {
+              throw new errors_1.InvalidHexError();
+            }
+          }
+          return new _Pubkey(bytes);
+        } catch (e) {
+          if (e instanceof errors_1.InvalidPubkeyLengthError || e instanceof errors_1.InvalidHexError) {
+            throw e;
+          }
+          throw new errors_1.InvalidHexError();
+        }
+      }
+      /**
+       * Creates a Pubkey from raw bytes.
+       */
+      static fromBytes(bytes) {
+        if (bytes.length !== 32) {
+          throw new errors_1.InvalidPubkeyLengthError();
+        }
+        return new _Pubkey(new Uint8Array(bytes));
+      }
+      /**
+       * Returns the pubkey as a byte array.
+       */
+      toBytes() {
+        return new Uint8Array(this.data);
+      }
+      /**
+       * Returns the Base58 encoding of the pubkey.
+       */
+      toString() {
+        return bs58_1.default.encode(this.data);
+      }
+      /**
+       * Returns the hex encoding of the pubkey (without 0x prefix).
+       */
+      toHex() {
+        return Array.from(this.data).map((b) => b.toString(16).padStart(2, "0")).join("");
+      }
+      /**
+       * Returns true if the pubkey is all zeros.
+       */
+      isZero() {
+        return this.data.every((b) => b === 0);
+      }
+      /**
+       * Returns true if this pubkey equals another.
+       */
+      equals(other) {
+        return this.data.every((b, i) => b === other.data[i]);
+      }
+    };
+    exports2.Pubkey = Pubkey3;
+  }
+});
+
+// ../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/_u64.js
+var require_u64 = __commonJS({
+  "../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/_u64.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.toBig = exports2.shrSL = exports2.shrSH = exports2.rotrSL = exports2.rotrSH = exports2.rotrBL = exports2.rotrBH = exports2.rotr32L = exports2.rotr32H = exports2.rotlSL = exports2.rotlSH = exports2.rotlBL = exports2.rotlBH = exports2.add5L = exports2.add5H = exports2.add4L = exports2.add4H = exports2.add3L = exports2.add3H = void 0;
+    exports2.add = add;
+    exports2.fromBig = fromBig;
+    exports2.split = split;
+    var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+    var _32n = /* @__PURE__ */ BigInt(32);
+    function fromBig(n, le = false) {
+      if (le)
+        return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+      return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+    }
+    function split(lst, le = false) {
+      const len = lst.length;
+      let Ah = new Uint32Array(len);
+      let Al = new Uint32Array(len);
+      for (let i = 0; i < len; i++) {
+        const { h, l } = fromBig(lst[i], le);
+        [Ah[i], Al[i]] = [h, l];
+      }
+      return [Ah, Al];
+    }
+    var toBig = (h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0);
+    exports2.toBig = toBig;
+    var shrSH = (h, _l, s) => h >>> s;
+    exports2.shrSH = shrSH;
+    var shrSL = (h, l, s) => h << 32 - s | l >>> s;
+    exports2.shrSL = shrSL;
+    var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+    exports2.rotrSH = rotrSH;
+    var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+    exports2.rotrSL = rotrSL;
+    var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+    exports2.rotrBH = rotrBH;
+    var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+    exports2.rotrBL = rotrBL;
+    var rotr32H = (_h, l) => l;
+    exports2.rotr32H = rotr32H;
+    var rotr32L = (h, _l) => h;
+    exports2.rotr32L = rotr32L;
+    var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+    exports2.rotlSH = rotlSH;
+    var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+    exports2.rotlSL = rotlSL;
+    var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+    exports2.rotlBH = rotlBH;
+    var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+    exports2.rotlBL = rotlBL;
+    function add(Ah, Al, Bh, Bl) {
+      const l = (Al >>> 0) + (Bl >>> 0);
+      return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+    }
+    var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+    exports2.add3L = add3L;
+    var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+    exports2.add3H = add3H;
+    var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+    exports2.add4L = add4L;
+    var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+    exports2.add4H = add4H;
+    var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+    exports2.add5L = add5L;
+    var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+    exports2.add5H = add5H;
+    var u64 = {
+      fromBig,
+      split,
+      toBig,
+      shrSH,
+      shrSL,
+      rotrSH,
+      rotrSL,
+      rotrBH,
+      rotrBL,
+      rotr32H,
+      rotr32L,
+      rotlSH,
+      rotlSL,
+      rotlBH,
+      rotlBL,
+      add,
+      add3L,
+      add3H,
+      add4L,
+      add4H,
+      add5H,
+      add5L
+    };
+    exports2.default = u64;
+  }
+});
+
+// ../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/cryptoNode.js
+var require_cryptoNode = __commonJS({
+  "../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/cryptoNode.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.crypto = void 0;
+    var nc = require("crypto");
+    exports2.crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
+  }
+});
+
+// ../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/utils.js
+var require_utils = __commonJS({
+  "../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/utils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.wrapXOFConstructorWithOpts = exports2.wrapConstructorWithOpts = exports2.wrapConstructor = exports2.Hash = exports2.nextTick = exports2.swap32IfBE = exports2.byteSwapIfBE = exports2.swap8IfBE = exports2.isLE = void 0;
+    exports2.isBytes = isBytes;
+    exports2.anumber = anumber;
+    exports2.abytes = abytes;
+    exports2.ahash = ahash;
+    exports2.aexists = aexists;
+    exports2.aoutput = aoutput;
+    exports2.u8 = u8;
+    exports2.u32 = u32;
+    exports2.clean = clean;
+    exports2.createView = createView;
+    exports2.rotr = rotr;
+    exports2.rotl = rotl;
+    exports2.byteSwap = byteSwap;
+    exports2.byteSwap32 = byteSwap32;
+    exports2.bytesToHex = bytesToHex2;
+    exports2.hexToBytes = hexToBytes2;
+    exports2.asyncLoop = asyncLoop;
+    exports2.utf8ToBytes = utf8ToBytes;
+    exports2.bytesToUtf8 = bytesToUtf8;
+    exports2.toBytes = toBytes;
+    exports2.kdfInputToBytes = kdfInputToBytes;
+    exports2.concatBytes = concatBytes;
+    exports2.checkOpts = checkOpts;
+    exports2.createHasher = createHasher;
+    exports2.createOptHasher = createOptHasher;
+    exports2.createXOFer = createXOFer;
+    exports2.randomBytes = randomBytes;
+    var crypto_1 = require_cryptoNode();
+    function isBytes(a) {
+      return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+    }
+    function anumber(n) {
+      if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error("positive integer expected, got " + n);
+    }
+    function abytes(b, ...lengths) {
+      if (!isBytes(b))
+        throw new Error("Uint8Array expected");
+      if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+    }
+    function ahash(h) {
+      if (typeof h !== "function" || typeof h.create !== "function")
+        throw new Error("Hash should be wrapped by utils.createHasher");
+      anumber(h.outputLen);
+      anumber(h.blockLen);
+    }
+    function aexists(instance, checkFinished = true) {
+      if (instance.destroyed)
+        throw new Error("Hash instance has been destroyed");
+      if (checkFinished && instance.finished)
+        throw new Error("Hash#digest() has already been called");
+    }
+    function aoutput(out, instance) {
+      abytes(out);
+      const min = instance.outputLen;
+      if (out.length < min) {
+        throw new Error("digestInto() expects output buffer of length at least " + min);
+      }
+    }
+    function u8(arr) {
+      return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+    }
+    function u32(arr) {
+      return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+    }
+    function clean(...arrays) {
+      for (let i = 0; i < arrays.length; i++) {
+        arrays[i].fill(0);
+      }
+    }
+    function createView(arr) {
+      return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+    }
+    function rotr(word, shift) {
+      return word << 32 - shift | word >>> shift;
+    }
+    function rotl(word, shift) {
+      return word << shift | word >>> 32 - shift >>> 0;
+    }
+    exports2.isLE = (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+    function byteSwap(word) {
+      return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+    }
+    exports2.swap8IfBE = exports2.isLE ? (n) => n : (n) => byteSwap(n);
+    exports2.byteSwapIfBE = exports2.swap8IfBE;
+    function byteSwap32(arr) {
+      for (let i = 0; i < arr.length; i++) {
+        arr[i] = byteSwap(arr[i]);
+      }
+      return arr;
+    }
+    exports2.swap32IfBE = exports2.isLE ? (u) => u : byteSwap32;
+    var hasHexBuiltin = /* @__PURE__ */ (() => (
+      // @ts-ignore
+      typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+    ))();
+    var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+    function bytesToHex2(bytes) {
+      abytes(bytes);
+      if (hasHexBuiltin)
+        return bytes.toHex();
+      let hex = "";
+      for (let i = 0; i < bytes.length; i++) {
+        hex += hexes[bytes[i]];
+      }
+      return hex;
+    }
+    var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+    function asciiToBase16(ch) {
+      if (ch >= asciis._0 && ch <= asciis._9)
+        return ch - asciis._0;
+      if (ch >= asciis.A && ch <= asciis.F)
+        return ch - (asciis.A - 10);
+      if (ch >= asciis.a && ch <= asciis.f)
+        return ch - (asciis.a - 10);
+      return;
+    }
+    function hexToBytes2(hex) {
+      if (typeof hex !== "string")
+        throw new Error("hex string expected, got " + typeof hex);
+      if (hasHexBuiltin)
+        return Uint8Array.fromHex(hex);
+      const hl = hex.length;
+      const al = hl / 2;
+      if (hl % 2)
+        throw new Error("hex string expected, got unpadded hex of length " + hl);
+      const array = new Uint8Array(al);
+      for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+        const n1 = asciiToBase16(hex.charCodeAt(hi));
+        const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+        if (n1 === void 0 || n2 === void 0) {
+          const char = hex[hi] + hex[hi + 1];
+          throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+        }
+        array[ai] = n1 * 16 + n2;
+      }
+      return array;
+    }
+    var nextTick = async () => {
+    };
+    exports2.nextTick = nextTick;
+    async function asyncLoop(iters, tick, cb) {
+      let ts = Date.now();
+      for (let i = 0; i < iters; i++) {
+        cb(i);
+        const diff = Date.now() - ts;
+        if (diff >= 0 && diff < tick)
+          continue;
+        await (0, exports2.nextTick)();
+        ts += diff;
+      }
+    }
+    function utf8ToBytes(str) {
+      if (typeof str !== "string")
+        throw new Error("string expected");
+      return new Uint8Array(new TextEncoder().encode(str));
+    }
+    function bytesToUtf8(bytes) {
+      return new TextDecoder().decode(bytes);
+    }
+    function toBytes(data) {
+      if (typeof data === "string")
+        data = utf8ToBytes(data);
+      abytes(data);
+      return data;
+    }
+    function kdfInputToBytes(data) {
+      if (typeof data === "string")
+        data = utf8ToBytes(data);
+      abytes(data);
+      return data;
+    }
+    function concatBytes(...arrays) {
+      let sum = 0;
+      for (let i = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        abytes(a);
+        sum += a.length;
+      }
+      const res = new Uint8Array(sum);
+      for (let i = 0, pad = 0; i < arrays.length; i++) {
+        const a = arrays[i];
+        res.set(a, pad);
+        pad += a.length;
+      }
+      return res;
+    }
+    function checkOpts(defaults, opts) {
+      if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]")
+        throw new Error("options should be object or undefined");
+      const merged = Object.assign(defaults, opts);
+      return merged;
+    }
+    var Hash = class {
+    };
+    exports2.Hash = Hash;
+    function createHasher(hashCons) {
+      const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+      const tmp = hashCons();
+      hashC.outputLen = tmp.outputLen;
+      hashC.blockLen = tmp.blockLen;
+      hashC.create = () => hashCons();
+      return hashC;
+    }
+    function createOptHasher(hashCons) {
+      const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+      const tmp = hashCons({});
+      hashC.outputLen = tmp.outputLen;
+      hashC.blockLen = tmp.blockLen;
+      hashC.create = (opts) => hashCons(opts);
+      return hashC;
+    }
+    function createXOFer(hashCons) {
+      const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+      const tmp = hashCons({});
+      hashC.outputLen = tmp.outputLen;
+      hashC.blockLen = tmp.blockLen;
+      hashC.create = (opts) => hashCons(opts);
+      return hashC;
+    }
+    exports2.wrapConstructor = createHasher;
+    exports2.wrapConstructorWithOpts = createOptHasher;
+    exports2.wrapXOFConstructorWithOpts = createXOFer;
+    function randomBytes(bytesLength = 32) {
+      if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === "function") {
+        return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+      }
+      if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === "function") {
+        return Uint8Array.from(crypto_1.crypto.randomBytes(bytesLength));
+      }
+      throw new Error("crypto.getRandomValues must be defined");
+    }
+  }
+});
+
+// ../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/sha3.js
+var require_sha3 = __commonJS({
+  "../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/sha3.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.shake256 = exports2.shake128 = exports2.keccak_512 = exports2.keccak_384 = exports2.keccak_256 = exports2.keccak_224 = exports2.sha3_512 = exports2.sha3_384 = exports2.sha3_256 = exports2.sha3_224 = exports2.Keccak = void 0;
+    exports2.keccakP = keccakP;
+    var _u64_ts_1 = require_u64();
+    var utils_ts_1 = require_utils();
+    var _0n = BigInt(0);
+    var _1n = BigInt(1);
+    var _2n = BigInt(2);
+    var _7n = BigInt(7);
+    var _256n = BigInt(256);
+    var _0x71n = BigInt(113);
+    var SHA3_PI = [];
+    var SHA3_ROTL = [];
+    var _SHA3_IOTA = [];
+    for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+      [x, y] = [y, (2 * x + 3 * y) % 5];
+      SHA3_PI.push(2 * (5 * y + x));
+      SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+      let t = _0n;
+      for (let j = 0; j < 7; j++) {
+        R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+        if (R & _2n)
+          t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+      }
+      _SHA3_IOTA.push(t);
+    }
+    var IOTAS = (0, _u64_ts_1.split)(_SHA3_IOTA, true);
+    var SHA3_IOTA_H = IOTAS[0];
+    var SHA3_IOTA_L = IOTAS[1];
+    var rotlH = (h, l, s) => s > 32 ? (0, _u64_ts_1.rotlBH)(h, l, s) : (0, _u64_ts_1.rotlSH)(h, l, s);
+    var rotlL = (h, l, s) => s > 32 ? (0, _u64_ts_1.rotlBL)(h, l, s) : (0, _u64_ts_1.rotlSL)(h, l, s);
+    function keccakP(s, rounds = 24) {
+      const B = new Uint32Array(5 * 2);
+      for (let round = 24 - rounds; round < 24; round++) {
+        for (let x = 0; x < 10; x++)
+          B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+        for (let x = 0; x < 10; x += 2) {
+          const idx1 = (x + 8) % 10;
+          const idx0 = (x + 2) % 10;
+          const B0 = B[idx0];
+          const B1 = B[idx0 + 1];
+          const Th = rotlH(B0, B1, 1) ^ B[idx1];
+          const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+          for (let y = 0; y < 50; y += 10) {
+            s[x + y] ^= Th;
+            s[x + y + 1] ^= Tl;
+          }
+        }
+        let curH = s[2];
+        let curL = s[3];
+        for (let t = 0; t < 24; t++) {
+          const shift = SHA3_ROTL[t];
+          const Th = rotlH(curH, curL, shift);
+          const Tl = rotlL(curH, curL, shift);
+          const PI = SHA3_PI[t];
+          curH = s[PI];
+          curL = s[PI + 1];
+          s[PI] = Th;
+          s[PI + 1] = Tl;
+        }
+        for (let y = 0; y < 50; y += 10) {
+          for (let x = 0; x < 10; x++)
+            B[x] = s[y + x];
+          for (let x = 0; x < 10; x++)
+            s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+        }
+        s[0] ^= SHA3_IOTA_H[round];
+        s[1] ^= SHA3_IOTA_L[round];
+      }
+      (0, utils_ts_1.clean)(B);
+    }
+    var Keccak = class _Keccak extends utils_ts_1.Hash {
+      // NOTE: we accept arguments in bytes instead of bits here.
+      constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+        super();
+        this.pos = 0;
+        this.posOut = 0;
+        this.finished = false;
+        this.destroyed = false;
+        this.enableXOF = false;
+        this.blockLen = blockLen;
+        this.suffix = suffix;
+        this.outputLen = outputLen;
+        this.enableXOF = enableXOF;
+        this.rounds = rounds;
+        (0, utils_ts_1.anumber)(outputLen);
+        if (!(0 < blockLen && blockLen < 200))
+          throw new Error("only keccak-f1600 function is supported");
+        this.state = new Uint8Array(200);
+        this.state32 = (0, utils_ts_1.u32)(this.state);
+      }
+      clone() {
+        return this._cloneInto();
+      }
+      keccak() {
+        (0, utils_ts_1.swap32IfBE)(this.state32);
+        keccakP(this.state32, this.rounds);
+        (0, utils_ts_1.swap32IfBE)(this.state32);
+        this.posOut = 0;
+        this.pos = 0;
+      }
+      update(data) {
+        (0, utils_ts_1.aexists)(this);
+        data = (0, utils_ts_1.toBytes)(data);
+        (0, utils_ts_1.abytes)(data);
+        const { blockLen, state } = this;
+        const len = data.length;
+        for (let pos = 0; pos < len; ) {
+          const take = Math.min(blockLen - this.pos, len - pos);
+          for (let i = 0; i < take; i++)
+            state[this.pos++] ^= data[pos++];
+          if (this.pos === blockLen)
+            this.keccak();
+        }
+        return this;
+      }
+      finish() {
+        if (this.finished)
+          return;
+        this.finished = true;
+        const { state, suffix, pos, blockLen } = this;
+        state[pos] ^= suffix;
+        if ((suffix & 128) !== 0 && pos === blockLen - 1)
+          this.keccak();
+        state[blockLen - 1] ^= 128;
+        this.keccak();
+      }
+      writeInto(out) {
+        (0, utils_ts_1.aexists)(this, false);
+        (0, utils_ts_1.abytes)(out);
+        this.finish();
+        const bufferOut = this.state;
+        const { blockLen } = this;
+        for (let pos = 0, len = out.length; pos < len; ) {
+          if (this.posOut >= blockLen)
+            this.keccak();
+          const take = Math.min(blockLen - this.posOut, len - pos);
+          out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+          this.posOut += take;
+          pos += take;
+        }
+        return out;
+      }
+      xofInto(out) {
+        if (!this.enableXOF)
+          throw new Error("XOF is not possible for this instance");
+        return this.writeInto(out);
+      }
+      xof(bytes) {
+        (0, utils_ts_1.anumber)(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+      }
+      digestInto(out) {
+        (0, utils_ts_1.aoutput)(out, this);
+        if (this.finished)
+          throw new Error("digest() was already called");
+        this.writeInto(out);
+        this.destroy();
+        return out;
+      }
+      digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+      }
+      destroy() {
+        this.destroyed = true;
+        (0, utils_ts_1.clean)(this.state);
+      }
+      _cloneInto(to) {
+        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+        to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+        to.state32.set(this.state32);
+        to.pos = this.pos;
+        to.posOut = this.posOut;
+        to.finished = this.finished;
+        to.rounds = rounds;
+        to.suffix = suffix;
+        to.outputLen = outputLen;
+        to.enableXOF = enableXOF;
+        to.destroyed = this.destroyed;
+        return to;
+      }
+    };
+    exports2.Keccak = Keccak;
+    var gen = (suffix, blockLen, outputLen) => (0, utils_ts_1.createHasher)(() => new Keccak(blockLen, suffix, outputLen));
+    exports2.sha3_224 = (() => gen(6, 144, 224 / 8))();
+    exports2.sha3_256 = (() => gen(6, 136, 256 / 8))();
+    exports2.sha3_384 = (() => gen(6, 104, 384 / 8))();
+    exports2.sha3_512 = (() => gen(6, 72, 512 / 8))();
+    exports2.keccak_224 = (() => gen(1, 144, 224 / 8))();
+    exports2.keccak_256 = (() => gen(1, 136, 256 / 8))();
+    exports2.keccak_384 = (() => gen(1, 104, 384 / 8))();
+    exports2.keccak_512 = (() => gen(1, 72, 512 / 8))();
+    var genShake = (suffix, blockLen, outputLen) => (0, utils_ts_1.createXOFer)((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+    exports2.shake128 = (() => genShake(31, 168, 128 / 8))();
+    exports2.shake256 = (() => genShake(31, 136, 256 / 8))();
+  }
+});
+
+// ../contracts/svm/escrow-encoding/typescript/dist/encoding-utils.js
+var require_encoding_utils = __commonJS({
+  "../contracts/svm/escrow-encoding/typescript/dist/encoding-utils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.encodeU64LE = encodeU64LE2;
+    exports2.keccak256 = keccak2563;
+    exports2.stringToBytes = stringToBytes;
+    exports2.isZeroBytes32 = isZeroBytes32;
+    var sha3_1 = require_sha3();
+    function encodeU64LE2(value) {
+      const buffer = new Uint8Array(8);
+      let v = value;
+      for (let i = 0; i < 8; i++) {
+        buffer[i] = Number(v & 0xffn);
+        v = v >> 8n;
+      }
+      return buffer;
+    }
+    function keccak2563(...data) {
+      const totalLength = data.reduce((sum, arr) => sum + arr.length, 0);
+      const combined = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const arr of data) {
+        combined.set(arr, offset);
+        offset += arr.length;
+      }
+      return (0, sha3_1.keccak_256)(combined);
+    }
+    function stringToBytes(s) {
+      return new TextEncoder().encode(s);
+    }
+    function isZeroBytes32(data) {
+      if (data.length !== 32)
+        return false;
+      return data.every((b) => b === 0);
+    }
+  }
+});
+
+// ../contracts/svm/escrow-encoding/typescript/dist/escrow-domain.js
+var require_escrow_domain = __commonJS({
+  "../contracts/svm/escrow-encoding/typescript/dist/escrow-domain.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.escrowDomainPrefixBytes = escrowDomainPrefixBytes;
+    function escrowDomainPrefixBytes(domain) {
+      if (domain.clusterId.length !== 32) {
+        throw new Error(`EscrowDomain.clusterId must be 32 bytes, got ${domain.clusterId.length}`);
+      }
+      if (!Number.isInteger(domain.signatureDomainVersion) || domain.signatureDomainVersion < 1 || domain.signatureDomainVersion > 255) {
+        throw new Error(`EscrowDomain.signatureDomainVersion must be an integer in 1..=255, got ${domain.signatureDomainVersion}`);
+      }
+      return [
+        new TextEncoder().encode("escrow"),
+        new Uint8Array([domain.signatureDomainVersion]),
+        domain.clusterId,
+        domain.programId.toBytes()
+      ];
+    }
+  }
+});
+
+// ../contracts/svm/escrow-encoding/typescript/dist/deposit-encoder.js
+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;
+    var encoding_utils_1 = require_encoding_utils();
+    var escrow_domain_1 = require_escrow_domain();
+    var errors_1 = require_errors();
+    function computeDepositHash2(params, domain) {
+      if (params.paymentId.length !== 32 || (0, encoding_utils_1.isZeroBytes32)(params.paymentId)) {
+        throw new errors_1.ZeroPaymentIdError();
+      }
+      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();
+      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));
+    }
+  }
+});
+
+// ../contracts/svm/escrow-encoding/typescript/dist/reserve-encoder.js
+var require_reserve_encoder3 = __commonJS({
+  "../contracts/svm/escrow-encoding/typescript/dist/reserve-encoder.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.computeReserveHash = computeReserveHash;
+    var encoding_utils_1 = require_encoding_utils();
+    var escrow_domain_1 = require_escrow_domain();
+    var errors_1 = require_errors();
+    function computeReserveHash(params, 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();
+      return (0, encoding_utils_1.keccak256)(...(0, escrow_domain_1.escrowDomainPrefixBytes)(domain), (0, encoding_utils_1.stringToBytes)("reserve"), params.recipient.toBytes(), params.depositHash);
+    }
+  }
+});
+
+// ../contracts/svm/escrow-encoding/typescript/dist/release-encoder.js
+var require_release_encoder = __commonJS({
+  "../contracts/svm/escrow-encoding/typescript/dist/release-encoder.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.computeReleaseHash = computeReleaseHash;
+    var encoding_utils_1 = require_encoding_utils();
+    var escrow_domain_1 = require_escrow_domain();
+    var errors_1 = require_errors();
+    function computeReleaseHash(params, 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);
+    }
+  }
+});
+
+// ../contracts/svm/escrow-encoding/typescript/dist/refund-encoder.js
+var require_refund_encoder = __commonJS({
+  "../contracts/svm/escrow-encoding/typescript/dist/refund-encoder.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.computeRefundHash = computeRefundHash;
+    var encoding_utils_1 = require_encoding_utils();
+    var escrow_domain_1 = require_escrow_domain();
+    var errors_1 = require_errors();
+    function computeRefundHash(params, 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);
+    }
+  }
+});
+
+// ../contracts/svm/escrow-encoding/typescript/dist/nonce-generator.js
+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.generateNonce = generateNonce2;
+    var crypto_1 = require("crypto");
+    exports2.REPLAY_SLOTS = 235;
+    exports2.MAX_VALID_SLOT = exports2.REPLAY_SLOTS - 1;
+    var NONCE_BUCKET_MASK = 131071;
+    var NONCE_BUCKET_SHIFT = 32n;
+    function generateNonce2() {
+      const bucketBytes = (0, crypto_1.randomBytes)(4);
+      const bucketID = bucketBytes.readUInt32LE(0) & NONCE_BUCKET_MASK;
+      let slot;
+      do {
+        slot = (0, crypto_1.randomBytes)(1)[0];
+      } while (slot >= exports2.REPLAY_SLOTS);
+      return BigInt(bucketID) << NONCE_BUCKET_SHIFT | BigInt(slot);
+    }
+  }
+});
+
+// ../contracts/svm/escrow-encoding/typescript/dist/index.js
+var require_dist3 = __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;
+    var pubkey_1 = require_pubkey();
+    Object.defineProperty(exports2, "Pubkey", { enumerable: true, get: function() {
+      return pubkey_1.Pubkey;
+    } });
+    var encoding_utils_1 = require_encoding_utils();
+    Object.defineProperty(exports2, "encodeU64LE", { enumerable: true, get: function() {
+      return encoding_utils_1.encodeU64LE;
+    } });
+    Object.defineProperty(exports2, "keccak256", { enumerable: true, get: function() {
+      return encoding_utils_1.keccak256;
+    } });
+    Object.defineProperty(exports2, "stringToBytes", { enumerable: true, get: function() {
+      return encoding_utils_1.stringToBytes;
+    } });
+    Object.defineProperty(exports2, "isZeroBytes32", { enumerable: true, get: function() {
+      return encoding_utils_1.isZeroBytes32;
+    } });
+    var escrow_domain_1 = require_escrow_domain();
+    Object.defineProperty(exports2, "escrowDomainPrefixBytes", { enumerable: true, get: function() {
+      return escrow_domain_1.escrowDomainPrefixBytes;
+    } });
+    var errors_1 = require_errors();
+    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, "ZeroDepositorError", { enumerable: true, get: function() {
+      return errors_1.ZeroDepositorError;
+    } });
+    Object.defineProperty(exports2, "ZeroMintError", { enumerable: true, get: function() {
+      return errors_1.ZeroMintError;
+    } });
+    Object.defineProperty(exports2, "ZeroAmountError", { enumerable: true, get: function() {
+      return errors_1.ZeroAmountError;
+    } });
+    Object.defineProperty(exports2, "ZeroReserverError", { enumerable: true, get: function() {
+      return errors_1.ZeroReserverError;
+    } });
+    Object.defineProperty(exports2, "ZeroReleaserError", { enumerable: true, get: function() {
+      return errors_1.ZeroReleaserError;
+    } });
+    Object.defineProperty(exports2, "ZeroRecipientError", { enumerable: true, get: function() {
+      return errors_1.ZeroRecipientError;
+    } });
+    Object.defineProperty(exports2, "ZeroDepositHashError", { enumerable: true, get: function() {
+      return errors_1.ZeroDepositHashError;
+    } });
+    Object.defineProperty(exports2, "InvalidPubkeyLengthError", { enumerable: true, get: function() {
+      return errors_1.InvalidPubkeyLengthError;
+    } });
+    Object.defineProperty(exports2, "InvalidBase58Error", { enumerable: true, get: function() {
+      return errors_1.InvalidBase58Error;
+    } });
+    Object.defineProperty(exports2, "InvalidHexError", { enumerable: true, get: function() {
+      return errors_1.InvalidHexError;
+    } });
+    var deposit_encoder_1 = require_deposit_encoder3();
+    Object.defineProperty(exports2, "computeDepositHash", { enumerable: true, get: function() {
+      return deposit_encoder_1.computeDepositHash;
+    } });
+    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, "computeReleaseHash", { enumerable: true, get: function() {
+      return release_encoder_1.computeReleaseHash;
+    } });
+    var refund_encoder_1 = require_refund_encoder();
+    Object.defineProperty(exports2, "computeRefundHash", { enumerable: true, get: function() {
+      return refund_encoder_1.computeRefundHash;
+    } });
+    var nonce_generator_1 = require_nonce_generator2();
+    Object.defineProperty(exports2, "generateNonce", { enumerable: true, get: function() {
+      return nonce_generator_1.generateNonce;
+    } });
+    Object.defineProperty(exports2, "REPLAY_SLOTS", { enumerable: true, get: function() {
+      return nonce_generator_1.REPLAY_SLOTS;
+    } });
+    Object.defineProperty(exports2, "MAX_VALID_SLOT", { enumerable: true, get: function() {
+      return nonce_generator_1.MAX_VALID_SLOT;
+    } });
+  }
+});
+
+// src/cli/quote-status.ts
+var import_commander = require("commander");
+
+// src/generated/core/OpenAPI.ts
+var Interceptors = class {
+  constructor() {
+    this._fns = [];
+  }
+  eject(fn) {
+    const index = this._fns.indexOf(fn);
+    if (index !== -1) {
+      this._fns = [...this._fns.slice(0, index), ...this._fns.slice(index + 1)];
+    }
+  }
+  use(fn) {
+    this._fns = [...this._fns, fn];
+  }
+};
+var OpenAPI = {
+  BASE: "https://api.atum.network",
+  CREDENTIALS: "include",
+  ENCODE_PATH: void 0,
+  HEADERS: void 0,
+  PASSWORD: void 0,
+  TOKEN: void 0,
+  USERNAME: void 0,
+  VERSION: "1.0.0",
+  WITH_CREDENTIALS: false,
+  interceptors: {
+    request: new Interceptors(),
+    response: new Interceptors()
+  }
+};
+
+// src/generated/core/BaseHttpRequest.ts
+var BaseHttpRequest = class {
+  constructor(config) {
+    this.config = config;
+  }
+};
+
+// src/generated/core/request.ts
+var import_axios = __toESM(require("axios"));
+
+// src/generated/core/ApiError.ts
+var ApiError = class extends Error {
+  constructor(request2, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request2;
+  }
+};
+
+// src/generated/core/CancelablePromise.ts
+var CancelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var CancelablePromise = class {
+  constructor(executor) {
+    this._isResolved = false;
+    this._isRejected = false;
+    this._isCancelled = false;
+    this.cancelHandlers = [];
+    this.promise = new Promise((resolve2, reject) => {
+      this._resolve = resolve2;
+      this._reject = reject;
+      const onResolve = (value) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isResolved = true;
+        if (this._resolve) this._resolve(value);
+      };
+      const onReject = (reason) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isRejected = true;
+        if (this._reject) this._reject(reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this.cancelHandlers.push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => this._isResolved
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => this._isRejected
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => this._isCancelled
+      });
+      return executor(onResolve, onReject, onCancel);
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+  then(onFulfilled, onRejected) {
+    return this.promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this.promise.catch(onRejected);
+  }
+  finally(onFinally) {
+    return this.promise.finally(onFinally);
+  }
+  cancel() {
+    if (this._isResolved || this._isRejected || this._isCancelled) {
+      return;
+    }
+    this._isCancelled = true;
+    if (this.cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this.cancelHandlers) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    this.cancelHandlers.length = 0;
+    if (this._reject) this._reject(new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return this._isCancelled;
+  }
+};
+
+// src/generated/core/request.ts
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+var isBlob = (value) => {
+  return value instanceof Blob;
+};
+var isFormData = (value) => {
+  return value instanceof FormData;
+};
+var isSuccess = (status) => {
+  return status >= 200 && status < 300;
+};
+var base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+var getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const encodePair = (key, value) => {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    if (value instanceof Date) {
+      append(key, value.toISOString());
+    } else if (Array.isArray(value)) {
+      value.forEach((v) => encodePair(key, v));
+    } else if (typeof value === "object") {
+      Object.entries(value).forEach(([k, v]) => encodePair(`${key}[${k}]`, v));
+    } else {
+      append(key, value);
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => encodePair(key, value));
+  return qs.length ? `?${qs.join("&")}` : "";
+};
+var getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    if (options.path?.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = config.BASE + path;
+  return options.query ? url + getQueryString(options.query) : url;
+};
+var getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process2 = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([, value]) => value !== void 0 && value !== null).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process2(key, v));
+      } else {
+        process2(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+};
+var resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+};
+var getHeaders = async (config, options) => {
+  const [token, username, password, additionalHeaders] = await Promise.all([
+    resolve(options, config.TOKEN),
+    resolve(options, config.USERNAME),
+    resolve(options, config.PASSWORD),
+    resolve(options, config.HEADERS)
+  ]);
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([, value]) => value !== void 0 && value !== null).reduce((headers2, [key, value]) => ({
+    ...headers2,
+    [key]: String(value)
+  }), {});
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body !== void 0) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  } else if (options.formData !== void 0) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    }
+  }
+  return headers;
+};
+var getRequestBody = (options) => {
+  if (options.body) {
+    return options.body;
+  }
+  return void 0;
+};
+var sendRequest = async (config, options, url, body, formData, headers, onCancel, axiosClient) => {
+  const controller = new AbortController();
+  let requestConfig = {
+    data: body ?? formData,
+    headers,
+    method: options.method,
+    signal: controller.signal,
+    url,
+    withCredentials: config.WITH_CREDENTIALS
+  };
+  onCancel(() => controller.abort());
+  for (const fn of config.interceptors.request._fns) {
+    requestConfig = await fn(requestConfig);
+  }
+  try {
+    return await axiosClient.request(requestConfig);
+  } catch (error) {
+    const axiosError = error;
+    if (axiosError.response) {
+      return axiosError.response;
+    }
+    throw error;
+  }
+};
+var getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers[responseHeader];
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+var getResponseBody = (response) => {
+  if (response.status !== 204) {
+    return response.data;
+  }
+  return void 0;
+};
+var catchErrorCodes = (options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    402: "Payment Required",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    406: "Not Acceptable",
+    407: "Proxy Authentication Required",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    411: "Length Required",
+    412: "Precondition Failed",
+    413: "Payload Too Large",
+    414: "URI Too Long",
+    415: "Unsupported Media Type",
+    416: "Range Not Satisfiable",
+    417: "Expectation Failed",
+    418: "Im a teapot",
+    421: "Misdirected Request",
+    422: "Unprocessable Content",
+    423: "Locked",
+    424: "Failed Dependency",
+    425: "Too Early",
+    426: "Upgrade Required",
+    428: "Precondition Required",
+    429: "Too Many Requests",
+    431: "Request Header Fields Too Large",
+    451: "Unavailable For Legal Reasons",
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+    505: "HTTP Version Not Supported",
+    506: "Variant Also Negotiates",
+    507: "Insufficient Storage",
+    508: "Loop Detected",
+    510: "Not Extended",
+    511: "Network Authentication Required",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    const errorStatus = result.status ?? "unknown";
+    const errorStatusText = result.statusText ?? "unknown";
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return void 0;
+      }
+    })();
+    throw new ApiError(
+      options,
+      result,
+      `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+    );
+  }
+};
+var request = (config, options, axiosClient = import_axios.default) => {
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options);
+      if (!onCancel.isCancelled) {
+        let response = await sendRequest(config, options, url, body, formData, headers, onCancel, axiosClient);
+        for (const fn of config.interceptors.response._fns) {
+          response = await fn(response);
+        }
+        const responseBody = getResponseBody(response);
+        const responseHeader = getResponseHeader(response, options.responseHeader);
+        const result = {
+          url,
+          ok: isSuccess(response.status),
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? responseBody
+        };
+        catchErrorCodes(options, result);
+        resolve2(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+// src/generated/core/AxiosHttpRequest.ts
+var AxiosHttpRequest = class extends BaseHttpRequest {
+  constructor(config) {
+    super(config);
+  }
+  /**
+   * Request method
+   * @param options The request options from the service
+   * @returns CancelablePromise<T>
+   * @throws ApiError
+   */
+  request(options) {
+    return request(this.config, options);
+  }
+};
+
+// src/generated/services.gen.ts
+var PaymentsService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Submit a payment request
+   * Initiates a payment by submitting a cryptographically signed payment request.
+   *
+   * The payment gateway will:
+   * 1. Validate the request and signatures
+   * 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
+   *
+   * @param data The data for the request.
+   * @param data.requestBody
+   * @returns PaymentResponse Payment request submitted successfully
+   * @throws ApiError
+   */
+  submitPayment(data) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/payments",
+      body: data.requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: "Invalid request",
+        500: "Internal server error"
+      }
+    });
+  }
+  /**
+   * Get payment status
+   * Retrieve the status of a payment by its ID
+   * @param data The data for the request.
+   * @param data.paymentId The ID of the payment to query
+   * @returns GetPaymentStatusResponse Payment status retrieved successfully
+   * @throws ApiError
+   */
+  getPaymentStatus(data) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/payments/{paymentId}/status",
+      path: {
+        paymentId: data.paymentId
+      },
+      errors: {
+        404: "Payment not found",
+        500: "Internal server error"
+      }
+    });
+  }
+  /**
+   * Resolve a request ID to a payment ID
+   * Looks up the payment ID associated with a given client-supplied request ID.
+   * Used by tooling like the payment explorer so callers can look a payment up
+   * by the request ID they originally submitted.
+   *
+   * @param data The data for the request.
+   * @param data.requestId The client-supplied request ID embedded in the payment request
+   * @returns ResolvePaymentResponse Payment found
+   * @throws ApiError
+   */
+  resolvePayment(data) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/payments/resolve",
+      query: {
+        request_id: data.requestId
+      },
+      errors: {
+        400: "Missing request_id parameter",
+        404: "No payment found for the given request ID",
+        500: "Internal server error"
+      }
+    });
+  }
+  /**
+   * Get step-by-step payment timeline
+   * Returns the settlement timeline for a payment, including every step the
+   * payment has passed through, per-step durations, chain IDs, transaction
+   * hashes, and — if the payment has failed — a structured error describing
+   * where and why it failed.
+   *
+   * @param data The data for the request.
+   * @param data.paymentId The ID of the payment to query
+   * @returns PaymentTimelineResponse Timeline retrieved successfully
+   * @throws ApiError
+   */
+  getPaymentTimeline(data) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/payments/{paymentId}/timeline",
+      path: {
+        paymentId: data.paymentId
+      },
+      errors: {
+        404: "Payment not found",
+        500: "Internal server error"
+      }
+    });
+  }
+  /**
+   * Prepare an unsigned payment request
+   * Generates an unsigned PaymentRequest object from human-readable inputs.
+   * This endpoint allows clients to:
+   * 1. Use friendly asset identifiers (e.g., "ethereum/usdc" instead of full CAIP-19)
+   * 2. Specify amounts in decimal format
+   * 3. Get back a complete PaymentRequest with typed data (eg EIP-712 for EVM-compatible chains) ready for signing
+   *
+   * The response includes everything needed to sign and submit a payment, except the signature itself.
+   *
+   * @param data The data for the request.
+   * @param data.requestBody
+   * @returns PreparePaymentResponse Payment request prepared successfully
+   * @throws ApiError
+   */
+  preparePayment(data) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/payments/prepare",
+      body: data.requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: "Invalid request parameters",
+        501: "Endpoint not yet implemented"
+      }
+    });
+  }
+};
+var AuthorizationsService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Request counterparty authorization
+   * Submits a PaymentRequest for counterparty authorization before settlement.
+   * The call blocks synchronously until the beneficiary PSP responds or the
+   * timeout expires (default 30 seconds).
+   *
+   * If authorized, the response includes the counterparty's proof which can
+   * be attached to the subsequent SubmitPayment call.
+   *
+   * Authorization and RFQ submission are separate steps. This endpoint does
+   * NOT trigger an auction — the originator must call SubmitPayment separately.
+   *
+   * @param data The data for the request.
+   * @param data.requestBody
+   * @returns AuthorizationResult Authorization decision received (authorized or declined)
+   * @throws ApiError
+   */
+  authorizePayment(data) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/payments/authorizations",
+      body: data.requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: "Invalid payment request",
+        404: "Counterparty not found (no registration for the resolved DID)",
+        502: "Counterparty webhook error (HTTP error or connection failure)",
+        504: "Authorization timed out (counterparty did not respond)"
+      }
+    });
+  }
+};
+var QuoteRequestsService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Create a quote-request batch
+   * Opens a quote-request batch: broadcasts the corridor to settlement agents and collects
+   * their signed quotes. This is the first phase of the two-phase quote → award flow — the
+   * originator later picks one quote and commits in a separate POST /v1/payments/awards call.
+   * No spend authorization is supplied here; `sender_auth` is deferred to award time.
+   *
+   * Wait modes (the `wait` query parameter):
+   * - `wait=false` (default): return 202 immediately with status `collecting`; poll
+   * GET /v1/payments/quote-requests/{quoteRequestId} until status is `ready`.
+   * - `wait=true`: hold the connection for up to
+   * min(quote_deadline, quote_sync_wait_seconds) and return 200 with the collected quotes
+   * (status `ready`). If the sync cap fires before the quote deadline, return 200 with
+   * status `collecting` and poll the status endpoint.
+   *
+   * Collection continues server-side until the quote deadline regardless of the HTTP
+   * connection, so quotes remain retrievable via the status endpoint in either mode.
+   *
+   * @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`).
+   * @returns QuoteRequestResponse Quote-request resolved synchronously. `status` is `ready` when quotes were collected,
+   * or `collecting` when the sync wait cap fired before the quote deadline.
+   *
+   * @returns QuoteRequestAccepted Quote-request accepted; collection continues asynchronously.
+   * @throws ApiError
+   */
+  createQuoteRequest(data) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/payments/quote-requests",
+      query: {
+        wait: data.wait
+      },
+      body: data.requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: "Invalid request",
+        500: "Internal server error"
+      }
+    });
+  }
+  /**
+   * Get quote-request batch status
+   * Returns the current state of a quote-request batch: a derived status, the collected
+   * quotes (each with its settler-signed `award_deadline`), and the awarded
+   * (quote_id, payment_id) pairs once a quote has been awarded. Used for async polling,
+   * connection-drop recovery, and re-reading quotes before awarding.
+   *
+   * The `status` here describes the quote-request batch lifecycle
+   * (`collecting`/`ready`/`awarded`/`expired`) and is disjoint from the payment-status enum
+   * returned by the award and payment-status endpoints.
+   *
+   * @param data The data for the request.
+   * @param data.quoteRequestId The ID of the quote-request batch to query
+   * @returns QuoteRequestStatusResponse Quote-request status retrieved successfully
+   * @throws ApiError
+   */
+  getQuoteRequestStatus(data) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/payments/quote-requests/{quoteRequestId}",
+      path: {
+        quoteRequestId: data.quoteRequestId
+      },
+      errors: {
+        404: "Quote-request not found, or not owned by the caller.",
+        500: "Internal server error"
+      }
+    });
+  }
+  /**
+   * Award a quote
+   * Commits to a payment by awarding one quote from a previously-collected batch. The
+   * originator submits two signatures from their wallet: `sender_auth` (the Permit2 deposit
+   * authorization) and a fully-formed `bid_award` declaration whose `authorization` carries
+   * the Escrow reserve-witness signature naming the chosen settler. The awarded quote is
+   * identified server-side by content-hashing `bid_award.fulfillment_quote_json` — there is
+   * no `quote_id` on the wire.
+   *
+   * From this call onward the `status` field describes the payment lifecycle (disjoint from the
+   * quote-request batch status). Track the payment afterward via
+   * GET /v1/payments/{paymentId}/status — a separate endpoint with its own status vocabulary
+   * (an in-progress payment reads as `pending` there).
+   *
+   * Wait modes (the `wait` query parameter):
+   * - `wait=false` (default): return 202 immediately with `payment_id` and status `awarding`;
+   * poll GET /v1/payments/{paymentId}/status.
+   * - `wait=true`: hold the connection for up to payment_sync_wait_seconds and
+   * return 200 with the payment result. If the sync cap fires first, return 200 with a
+   * non-terminal status (`awarding`); poll GET /v1/payments/{paymentId}/status.
+   *
+   * @param data The data for the request.
+   * @param data.requestBody
+   * @param data.wait Return a handle immediately (`false`, default) or hold the connection for the payment result (`true`).
+   * @returns AwardResponse Award resolved synchronously. `status` is `completed` with a fulfillment_confirmation
+   * when settlement finished within the sync wait, or a non-terminal payment status
+   * (e.g. `awarding`) if the cap fired first.
+   *
+   * @returns AwardAccepted Award accepted; settlement continues asynchronously.
+   * @throws ApiError
+   */
+  awardQuote(data) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/payments/awards",
+      query: {
+        wait: data.wait
+      },
+      body: data.requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: "Invalid request (bad signatures, expired quote, or ownership mismatch)",
+        409: `The quote, or another quote in the same batch, has already been awarded
+(single-award-per-batch, FR-09).
+`,
+        500: "Internal server error"
+      }
+    });
+  }
+};
+var HealthService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Health check
+   * Returns the health status of the service
+   * @returns unknown Service is healthy
+   * @throws ApiError
+   */
+  healthCheck() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/health"
+    });
+  }
+};
+
+// src/generated/PaymentGatewayClient.ts
+var PaymentGatewayClient = class {
+  constructor(config, HttpRequest = AxiosHttpRequest) {
+    this.request = new HttpRequest({
+      BASE: config?.BASE ?? "https://api.atum.network",
+      VERSION: config?.VERSION ?? "1.0.0",
+      WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
+      CREDENTIALS: config?.CREDENTIALS ?? "include",
+      TOKEN: config?.TOKEN,
+      USERNAME: config?.USERNAME,
+      PASSWORD: config?.PASSWORD,
+      HEADERS: config?.HEADERS,
+      ENCODE_PATH: config?.ENCODE_PATH,
+      interceptors: {
+        request: config?.interceptors?.request ?? new Interceptors(),
+        response: config?.interceptors?.response ?? new Interceptors()
+      }
+    });
+    this.authorizations = new AuthorizationsService(this.request);
+    this.health = new HealthService(this.request);
+    this.payments = new PaymentsService(this.request);
+    this.quoteRequests = new QuoteRequestsService(this.request);
+  }
+};
+
+// src/chain-adapters/evm.ts
+var import_ethers2 = require("ethers");
+
+// src/chain-adapters/types.ts
+var PERMIT_DEADLINE = BigInt(1924991999);
+function resolvePermitDeadline(deadlineSeconds) {
+  if (deadlineSeconds !== void 0) {
+    return BigInt(Math.floor(Date.now() / 1e3) + deadlineSeconds);
+  }
+  return PERMIT_DEADLINE;
+}
+function generatePermitNonce() {
+  const rand = new Uint32Array(1);
+  globalThis.crypto.getRandomValues(rand);
+  return (BigInt(Date.now()) << 32n) + BigInt(rand[0]);
+}
+function assertKeyMatchesSender(matches, sender, derived) {
+  if (!matches) {
+    throw new Error(`The private key derives ${derived}, which does not match the sender address ${sender}`);
+  }
+}
+
+// src/sender_auth_schemes/evm_permit2.ts
+var import_ethers = require("ethers");
+var import_evm_escrow_encoding = __toESM(require_dist());
+
+// src/chain-adapters/evm.ts
+var evmAdapter = {
+  turnkeyAddressFormat: "ADDRESS_FORMAT_ETHEREUM",
+  async buildAuthMessage({ sourceAsset, fulfillmentAmount, sourceDefaults, deadlineSeconds }) {
+    const sourceChainId = sourceAsset.split("/")[0];
+    const chainIdNum = parseInt(sourceChainId.split(":")[1]);
+    const tokenAddress = sourceAsset.split("/")[1].split(":")[1];
+    const permitParams = {
+      chainId: chainIdNum,
+      verifyingContract: import_evm_escrow_encoding.PERMIT2_CONTRACT_ADDRESS,
+      token: tokenAddress,
+      amount: fulfillmentAmount,
+      spender: sourceDefaults.escrowContract,
+      nonce: generatePermitNonce(),
+      deadline: resolvePermitDeadline(deadlineSeconds),
+      reserver: sourceDefaults.quoteSelector,
+      releaser: sourceDefaults.fulfillmentVerifierAccount
+    };
+    const messagePrehash = (0, import_evm_escrow_encoding.createPermitWitnessTransferFromPrehash)(permitParams);
+    const messageHash = (0, import_evm_escrow_encoding.hashPermitWitnessTransferFrom)(messagePrehash);
+    return {
+      messageScheme: "EVM_PERMIT2",
+      messageHash,
+      messagePrehash: JSON.stringify(messagePrehash)
+    };
+  },
+  formatPrivateKey(key) {
+    return key.startsWith("0x") ? key : "0x" + key;
+  },
+  // Value-free: never interpolate the key. A malformed key would otherwise be
+  // echoed by ethers.Wallet's "invalid BytesLike value" error.
+  validatePrivateKey(key) {
+    if (!/^(0x)?[0-9a-fA-F]{64}$/.test(key)) {
+      throw new Error("Invalid private key");
+    }
+  },
+  /**
+   * Sign the Permit2 PermitWitnessTransferFrom typed data via standard
+   * EIP-712 signing. The prehash is already shaped for direct consumption
+   * by ethers' signTypedData (Permit2 domain has no version/salt; types
+   * omits EIP712Domain since ethers generates that from the domain object).
+   */
+  async sign(signedMessage, privateKey) {
+    if (!signedMessage.message_prehash) {
+      throw new Error("EVM adapter sign(): signed_messages[i].message_prehash is required");
+    }
+    const prehash = JSON.parse(signedMessage.message_prehash);
+    const wallet = new import_ethers2.ethers.Wallet(privateKey);
+    return wallet.signTypedData(prehash.domain, prehash.types, prehash.message);
+  },
+  // Called after validatePrivateKey, so ethers.Wallet won't echo a malformed key.
+  verifyAddressMatchesKey(privateKey, address) {
+    const derived = new import_ethers2.ethers.Wallet(privateKey).address;
+    assertKeyMatchesSender(derived.toLowerCase() === address.toLowerCase(), address, derived);
+  }
+};
+
+// src/chain-adapters/tron.ts
+var import_ethers3 = require("ethers");
+
+// src/sender_auth_schemes/tron.ts
+var import_tvm_escrow_encoding = __toESM(require_dist2());
+
+// src/chain-adapters/tron.ts
+var CHAIN_ID_MAP = {
+  "shasta": 2494104990,
+  "mainnet": 728126428
+};
+var PERMIT2_FALLBACKS = {
+  "tron:shasta": "TPUqJPASUn1zLvbLBgRZ5pBYrx7WSe5ahp",
+  "tron:mainnet": "TJhMXTHQHeQyMD7TcKQFqAePNgG4b31H9m"
+};
+var tronAdapter = {
+  turnkeyAddressFormat: "ADDRESS_FORMAT_TRON",
+  async buildAuthMessage({ sourceAsset, fulfillmentAmount, sourceDefaults, deadlineSeconds }) {
+    const sourceChainId = sourceAsset.split("/")[0];
+    const chainName = sourceChainId.split(":")[1];
+    const chainIdNum = CHAIN_ID_MAP[chainName];
+    if (!chainIdNum) {
+      throw new Error(`Unsupported Tron chain: ${chainName}`);
+    }
+    const tokenAddress = sourceAsset.split("/")[1].split(":")[1];
+    let permit2Address = sourceDefaults.permit2Contract;
+    if (permit2Address === void 0) {
+      permit2Address = PERMIT2_FALLBACKS[sourceChainId];
+      if (!permit2Address) {
+        throw new Error(`don't know Permit2 address for chain ${sourceChainId}`);
+      }
+    }
+    const tvmParams = {
+      chainId: chainIdNum,
+      permit2Address,
+      tokenAddress,
+      amount: fulfillmentAmount,
+      spenderAddress: sourceDefaults.escrowContract,
+      nonce: generatePermitNonce(),
+      deadline: resolvePermitDeadline(deadlineSeconds),
+      reserverAddress: sourceDefaults.quoteSelector,
+      releaserAddress: sourceDefaults.fulfillmentVerifierAccount
+    };
+    const messagePrehash = (0, import_tvm_escrow_encoding.createTvmPermitWitnessTransferFromPrehash)(tvmParams);
+    const messageHash = (0, import_tvm_escrow_encoding.hashTvmPermitWitnessTransferFrom)(messagePrehash);
+    return {
+      messageScheme: "EVM_PERMIT2",
+      messageHash,
+      messagePrehash: JSON.stringify(messagePrehash)
+    };
+  },
+  resolveContractOverrides(sourceDefaults) {
+    return {
+      quote_selector: (0, import_tvm_escrow_encoding.normalizeAddress)(sourceDefaults.quoteSelector),
+      fulfillment_verifier: {
+        account: (0, import_tvm_escrow_encoding.normalizeAddress)(sourceDefaults.fulfillmentVerifierAccount),
+        endpoint: sourceDefaults.fulfillmentVerifierEndpoint
+      }
+    };
+  },
+  formatPrivateKey(key) {
+    return key.startsWith("0x") ? key.slice(2) : key;
+  },
+  // Value-free: never interpolate the key. A malformed key would otherwise be
+  // echoed by ethers.Wallet's "invalid BytesLike value" error.
+  validatePrivateKey(key) {
+    if (!/^(0x)?[0-9a-fA-F]{64}$/.test(key)) {
+      throw new Error("Invalid private key");
+    }
+  },
+  /**
+   * Tron uses TIP-712 typed-data — same wire format as EIP-712. The prehash
+   * built by createTvmPermitWitnessTransferFromPrehash is now directly
+   * consumable by `wallet.signTypedData(prehash.domain, prehash.types,
+   * prehash.message)`, but this adapter (an internal SDK helper) stays on the
+   * raw-hash sign for parity with the EVM adapter — e2e tests use ethers
+   * directly when they need the typed-data path.
+   */
+  async sign(signedMessage, privateKey) {
+    const wallet = new import_ethers3.ethers.Wallet(privateKey.startsWith("0x") ? privateKey : "0x" + privateKey);
+    return wallet.signingKey.sign(signedMessage.message).serialized;
+  },
+  // 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.
+  verifyAddressMatchesKey(privateKey, address) {
+    const key = privateKey.startsWith("0x") ? privateKey : "0x" + privateKey;
+    const derived = new import_ethers3.ethers.Wallet(key).address;
+    assertKeyMatchesSender(derived.toLowerCase() === (0, import_tvm_escrow_encoding.normalizeAddress)(address), address, derived);
+  }
+};
+
+// src/chain-adapters/solana.ts
+var import_tweetnacl = __toESM(require("tweetnacl"));
+var import_bs582 = __toESM(require("bs58"));
+var import_solana_escrow_encoding2 = __toESM(require_dist3());
+
+// src/sender_auth_schemes/solana.ts
+var import_ethers4 = require("ethers");
+var import_bs58 = __toESM(require("bs58"));
+var import_solana_escrow_encoding = __toESM(require_dist3());
+var REPLAY_HORIZON_SECS = 128;
+function bytesToHex(bytes) {
+  return (0, import_ethers4.hexlify)(bytes);
+}
+function hexToBytes(hex) {
+  return (0, import_ethers4.getBytes)(hex.startsWith("0x") ? hex : "0x" + hex);
+}
+function createSolanaDepositPrehash(paymentId, params) {
+  return {
+    payment_id: paymentId,
+    depositor: params.depositor,
+    mint: params.mint,
+    amount: params.amount.toString(),
+    reserver: params.reserver,
+    releaser: params.releaser,
+    nonce: params.nonce.toString(),
+    issued_at: params.issuedAt.toString(),
+    deadline: params.deadline.toString()
+  };
+}
+function generateSolanaNonce() {
+  return (0, import_solana_escrow_encoding.generateNonce)();
+}
+function clusterIdFromName(name) {
+  const encoded = new TextEncoder().encode(name);
+  if (encoded.length > 32) {
+    throw new Error(`cluster name too long for cluster_id: ${name} (${encoded.length} > 32 bytes)`);
+  }
+  const out = new Uint8Array(32);
+  out.set(encoded);
+  return out;
+}
+function generateSolanaPaymentIdV3(requestId) {
+  return (0, import_ethers4.keccak256)((0, import_ethers4.toUtf8Bytes)(requestId));
+}
+function hashSolanaDepositV3(prehash, domain) {
+  const hash = (0, import_solana_escrow_encoding.computeDepositHash)(
+    {
+      paymentId: hexToBytes(prehash.payment_id),
+      depositor: import_solana_escrow_encoding.Pubkey.fromBase58(prehash.depositor),
+      mint: import_solana_escrow_encoding.Pubkey.fromBase58(prehash.mint),
+      amount: BigInt(prehash.amount),
+      reserver: import_solana_escrow_encoding.Pubkey.fromBase58(prehash.reserver),
+      releaser: import_solana_escrow_encoding.Pubkey.fromBase58(prehash.releaser),
+      nonce: BigInt(prehash.nonce),
+      issuedAt: BigInt(prehash.issued_at),
+      deadline: BigInt(prehash.deadline)
+    },
+    domain
+  );
+  return bytesToHex(hash);
+}
+
+// src/chain-adapters/solana-clock.ts
+var DEFAULT_SOLANA_RPC_URLS = {
+  "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp": "https://api.mainnet-beta.solana.com",
+  EtWTRABZaYq6iMfeYKouRu166VU2xqa1: "https://api.devnet.solana.com",
+  "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z": "https://api.testnet.solana.com"
+};
+var SYSVAR_CLOCK_ADDRESS = "SysvarC1ock11111111111111111111111111111111";
+var SOLANA_CLOCK_RPC_TIMEOUT_MS = 2e3;
+var SOLANA_ISSUED_AT_FALLBACK_SKEW_SECS = 45n;
+var SOLANA_CLOCK_READ_GUARD_SECS = 2n;
+function resolveSolanaRpcUrl(sourceChainId, override) {
+  if (override) return override;
+  const reference = sourceChainId.split(":")[1];
+  return reference ? DEFAULT_SOLANA_RPC_URLS[reference] : void 0;
+}
+function readClockUnixTimeFromBase64(data) {
+  const bytes = Buffer.from(data, "base64");
+  if (bytes.length < 40) {
+    throw new Error(`Solana Clock sysvar data too short: ${bytes.length} bytes`);
+  }
+  return bytes.readBigInt64LE(32);
+}
+var readClusterUnixTime = async (rpcUrl, timeoutMs) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "getAccountInfo",
+        params: [SYSVAR_CLOCK_ADDRESS, { encoding: "base64" }]
+      }),
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      throw new Error(`Solana RPC ${rpcUrl} returned HTTP ${res.status}`);
+    }
+    const json = await res.json();
+    const data = json?.result?.value?.data?.[0];
+    if (typeof data !== "string") {
+      throw new Error("Solana Clock sysvar account data missing from RPC response");
+    }
+    return readClockUnixTimeFromBase64(data);
+  } finally {
+    clearTimeout(timer);
+  }
+};
+async function resolveSolanaIssuedAt(opts) {
+  const rpcUrl = resolveSolanaRpcUrl(opts.sourceChainId, opts.rpcUrlOverride);
+  if (rpcUrl) {
+    try {
+      const reader = opts.reader ?? readClusterUnixTime;
+      const onChain = await reader(rpcUrl, opts.timeoutMs ?? SOLANA_CLOCK_RPC_TIMEOUT_MS);
+      return onChain - SOLANA_CLOCK_READ_GUARD_SECS;
+    } catch (err) {
+      opts.logger?.warn(
+        { err: err instanceof Error ? err.message : String(err), rpcUrl },
+        "Solana cluster clock read failed; falling back to wall clock for issued_at"
+      );
+    }
+  }
+  return BigInt(Math.floor(Date.now() / 1e3)) - SOLANA_ISSUED_AT_FALLBACK_SKEW_SECS;
+}
+
+// src/chain-adapters/solana.ts
+var solanaAdapter = {
+  turnkeyAddressFormat: "ADDRESS_FORMAT_SOLANA",
+  async buildAuthMessage({ sourceAsset, depositor, fulfillmentAmount, requestId, sourceDefaults, solanaRpcUrl, solanaClockReader, solanaLogger }) {
+    const sourceChainId = sourceAsset.split("/")[0];
+    const tokenMint = sourceAsset.split("/")[1].split(":")[1];
+    const nonce = generateSolanaNonce();
+    const issuedAt = await resolveSolanaIssuedAt({
+      sourceChainId,
+      rpcUrlOverride: solanaRpcUrl,
+      reader: solanaClockReader,
+      logger: solanaLogger
+    });
+    const deadline = issuedAt + BigInt(REPLAY_HORIZON_SECS - 8);
+    const solanaParams = {
+      depositor,
+      mint: tokenMint,
+      amount: BigInt(fulfillmentAmount),
+      reserver: sourceDefaults.quoteSelector,
+      releaser: sourceDefaults.fulfillmentVerifierAccount,
+      nonce,
+      issuedAt,
+      deadline,
+      requestId
+    };
+    const paymentId = generateSolanaPaymentIdV3(requestId);
+    const prehash = createSolanaDepositPrehash(paymentId, solanaParams);
+    if (!sourceDefaults.svmSignatureClusterId || sourceDefaults.svmSignatureDomainVersion == null) {
+      throw new Error(
+        "Solana source requires svm_signature_cluster_id and svm_signature_domain_version from payment-gw /defaults (V3 escrow domain separation). Is the gateway on V3?"
+      );
+    }
+    const domain = {
+      clusterId: clusterIdFromName(sourceDefaults.svmSignatureClusterId),
+      signatureDomainVersion: sourceDefaults.svmSignatureDomainVersion,
+      programId: import_solana_escrow_encoding2.Pubkey.fromBase58(sourceDefaults.escrowContract)
+    };
+    const depositHash = hashSolanaDepositV3(prehash, domain);
+    return {
+      messageScheme: "SOLANA",
+      messageHash: depositHash,
+      messagePrehash: JSON.stringify(prehash)
+    };
+  },
+  formatPrivateKey(key) {
+    return key.startsWith("0x") ? key.slice(2) : key;
+  },
+  /**
+   * Solana has no EIP-712-style typed-data standard. The prehash structure
+   * still describes what was hashed (for debugging / wallet UX), but the
+   * canonical signing input is the chain-specific digest already in
+   * signedMessage.message. We sign that with ed25519.
+   */
+  async sign(signedMessage, privateKey) {
+    const messageBytes = new Uint8Array(Buffer.from(signedMessage.message.replace("0x", ""), "hex"));
+    const secretKey = secretKeyFromPrivate(privateKey);
+    const sig = import_tweetnacl.default.sign.detached(messageBytes, secretKey);
+    return "0x" + Buffer.from(sig).toString("hex");
+  },
+  /**
+   * Solana Ed25519 signatures are not public-key-recoverable (unlike EVM
+   * secp256k1, where ecrecover derives the signer from the signature). The
+   * on-chain Ed25519 verify instruction must therefore be given the signer's
+   * public key explicitly, so we ship it as signed_messages[0].payload.delegate_signer.
+   * In the self-custody CLI flow the signer is the depositor itself, so this
+   * equals source.account.
+   */
+  deriveDelegateSigner(privateKey) {
+    return deriveSolanaAddress(privateKey);
+  },
+  verifyAddressMatchesKey(privateKey, address) {
+    const derived = deriveSolanaAddress(privateKey);
+    assertKeyMatchesSender(derived === address, address, derived);
+  }
+};
+function deriveSolanaAddress(privateKey) {
+  return import_bs582.default.encode(import_tweetnacl.default.sign.keyPair.fromSecretKey(secretKeyFromPrivate(privateKey)).publicKey);
+}
+function secretKeyFromPrivate(privateKey) {
+  if (/^[0-9a-fA-F]{64}$/.test(privateKey)) {
+    const seed = new Uint8Array(32);
+    for (let i = 0; i < 32; i++) {
+      seed[i] = parseInt(privateKey.substring(i * 2, i * 2 + 2), 16);
+    }
+    return import_tweetnacl.default.sign.keyPair.fromSeed(seed).secretKey;
+  }
+  const decoded = import_bs582.default.decode(privateKey);
+  if (decoded.length === 64) {
+    return decoded;
+  }
+  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}`);
+}
+
+// src/chain-adapters/index.ts
+var adapters = {
+  "eip155": evmAdapter,
+  "tron": tronAdapter,
+  "solana": solanaAdapter
+};
+function getChainAdapter(sourceChainId) {
+  const prefix = sourceChainId.split(":")[0];
+  const adapter = adapters[prefix];
+  if (!adapter) throw new Error(`Unsupported source chain: ${sourceChainId}`);
+  return adapter;
+}
+
+// src/index.ts
+var PAYMENT_REQUEST_VERSION = "1.0";
+var defaultGateway = "https://payment-gateway-testnet.atumlabs.xyz";
+var DEFAULT_QUOTE_DEADLINE_SECONDS = 5;
+var DEFAULT_FULFILLMENT_DEADLINE_SECONDS = 3600;
+var DEFAULT_PAYMENT_QUOTE_DEADLINE_SECONDS = 10;
+var PROTOCOL_FEE_BIPS = 2n;
+var BIPS_DENOMINATOR = 10000n;
+function defaultMaxSourceAmount(fulfillmentAmount) {
+  const amount = BigInt(fulfillmentAmount);
+  const protocolFee = (amount * PROTOCOL_FEE_BIPS + BIPS_DENOMINATOR - 1n) / BIPS_DENOMINATOR;
+  return (amount + protocolFee).toString();
+}
+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.");
+  }
+  if (quoteDeadlineSeconds <= 0 || fulfillmentDeadlineSeconds <= 0) {
+    throw new Error("quoteDeadlineSeconds and fulfillmentDeadlineSeconds must be positive numbers of seconds.");
+  }
+  if (quoteDeadlineSeconds >= fulfillmentDeadlineSeconds) {
+    throw new Error(
+      `quoteDeadlineSeconds (${quoteDeadlineSeconds}) must be strictly less than fulfillmentDeadlineSeconds (${fulfillmentDeadlineSeconds}). The gateway rejects a quote_deadline that is not before fulfillment_deadline.`
+    );
+  }
+  const now = Date.now();
+  return {
+    quote_deadline: new Date(now + quoteDeadlineSeconds * 1e3).toISOString(),
+    fulfillment_deadline: new Date(now + fulfillmentDeadlineSeconds * 1e3).toISOString()
+  };
+}
+var PaymentGatewayClient2 = class extends PaymentGatewayClient {
+  constructor(config, HttpRequest = AxiosHttpRequest) {
+    super(config, HttpRequest);
+    this.baseUrl = config?.BASE ?? defaultGateway;
+  }
+  /**
+   * Fetches chain defaults from the payment gateway.
+   * 
+   * @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();
+        }
+      } catch {
+      }
+      const error = new Error(`Failed to fetch defaults for chain ${chainId}: ${response.statusText}`);
+      error.availableDefaults = availableDefaults;
+      throw error;
+    }
+    const data = await response.json();
+    if (!data.escrow_contract) {
+      throw new Error("defaults missing escrow_contract");
+    }
+    if (!data.fulfillment_proxy) {
+      throw new Error("defaults missing fulfillment_proxy");
+    }
+    if (!data.quote_selector) {
+      throw new Error("defaults missing quote_selector");
+    }
+    if (!data.fulfillment_verifier) {
+      throw new Error("defaults missing fulfillment_verifier");
+    }
+    if (!data.fulfillment_verifier.account) {
+      throw new Error("defaults missing fulfillment_verifier.account");
+    }
+    if (!data.fulfillment_verifier.endpoint) {
+      throw new Error("defaults missing fulfillment_verifier.endpoint");
+    }
+    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,
+      // 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
+    };
+  }
+  /**
+   * Prepares a payment request with defaults, ready for signing.
+   * 
+   * @param params Payment parameters
+   * @returns A complete PaymentRequest object without the signature
+   */
+  async preparePaymentRequest(params) {
+    const { quote_deadline, fulfillment_deadline } = resolveDeadlines(params, DEFAULT_PAYMENT_QUOTE_DEADLINE_SECONDS);
+    const sourceChainId = params.sourceAsset.split("/")[0];
+    const destChainId = params.destinationAsset.split("/")[0];
+    const [sourceDefaults, destDefaults] = await Promise.all([
+      this.fetchChainDefaults(sourceChainId),
+      this.fetchChainDefaults(destChainId)
+    ]);
+    const requestId = params.requestId || `${params.requestIdPrefix || "pmt-gw-sdk"}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    const adapter = getChainAdapter(sourceChainId);
+    const auth = await adapter.buildAuthMessage({
+      sourceAsset: params.sourceAsset,
+      depositor: params.depositor,
+      fulfillmentAmount: params.fulfillmentAmount,
+      requestId,
+      sourceDefaults,
+      deadlineSeconds: params.deadlineSeconds,
+      solanaRpcUrl: params.solanaRpcUrl
+    });
+    const contractOverrides = adapter.resolveContractOverrides?.(sourceDefaults);
+    return {
+      version: PAYMENT_REQUEST_VERSION,
+      request_id: requestId,
+      source: {
+        asset_identifier: params.sourceAsset,
+        account: params.depositor
+      },
+      destination: [{
+        asset_identifier: params.destinationAsset,
+        account: params.destinationAccount
+      }],
+      fulfillment_amount: params.fulfillmentAmount,
+      max_source_amount: params.maxSourceAmount ?? defaultMaxSourceAmount(params.fulfillmentAmount),
+      // REQUIRED (the gateway injects no defaults). Callers can widen the window via
+      // quoteDeadlineSeconds / fulfillmentDeadlineSeconds, e.g. for slow Turnkey signing.
+      quote_deadline,
+      fulfillment_deadline,
+      escrow_contract_address: sourceDefaults.escrowContract,
+      quote_selector: contractOverrides?.quote_selector ?? sourceDefaults.quoteSelector,
+      fulfillment_verifier: contractOverrides?.fulfillment_verifier ?? {
+        account: sourceDefaults.fulfillmentVerifierAccount,
+        endpoint: sourceDefaults.fulfillmentVerifierEndpoint
+      },
+      fulfillment_proxy: destDefaults.fulfillmentProxy,
+      ...params.settlerRequirements ? { settler_requirements: params.settlerRequirements } : {},
+      sender_auth: {
+        message_scheme: auth.messageScheme,
+        signed_messages: [{
+          message: auth.messageHash,
+          message_prehash: auth.messagePrehash,
+          signature: ""
+        }]
+      }
+    };
+  }
+  /**
+   * Prepares a quote-request body (`CreateQuoteRequest`), ready to POST to
+   * `/v1/payments/quote-requests`. This is the quote-phase counterpart to
+   * `preparePaymentRequest`: it builds the same corridor shape but **without
+   * `sender_auth`** — quote-time is the unauthenticated browse step, so no
+   * signing (and no private key) is required. The spend authorization arrives
+   * later, at the award call.
+   *
+   * Both deadlines are populated here because the gateway requires them and
+   * injects no defaults — it never mutates the originator-supplied body.
+   * `quote_deadline` bounds the collection window (default
+   * `DEFAULT_QUOTE_DEADLINE_SECONDS`); `fulfillment_deadline` bounds settlement
+   * (default `DEFAULT_FULFILLMENT_DEADLINE_SECONDS`). `quote_deadline` must be
+   * strictly earlier than `fulfillment_deadline` (enforced server-side; guarded
+   * here for a clear client-side error).
+   *
+   * `quote_deadline` is stamped client-side and the gateway rejects it unless it
+   * is strictly in the gateway's future, so a caller whose clock may lag the
+   * gateway should pass a larger `quoteDeadlineSeconds` (see
+   * `DEFAULT_QUOTE_DEADLINE_SECONDS` for why the default is what it is).
+   *
+   * Like `preparePaymentRequest`, this fetches the source/destination chain
+   * 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
+   * 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
+   * private key).
+   *
+   * @param params Quote-request parameters
+   * @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];
+    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,
+      source: {
+        asset_identifier: params.sourceAsset,
+        account: params.depositor
+      },
+      destination: [{
+        asset_identifier: params.destinationAsset,
+        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
+      // mutates the body. Ordering (quote < fulfillment) is enforced in resolveDeadlines.
+      quote_deadline,
+      fulfillment_deadline,
+      // Byte-identical contract fields to preparePaymentRequest (minus
+      // sender_auth): the same adapter override resolution runs on both paths,
+      // so a Tron base58 default becomes the identical canonical-hex value here
+      // as in the signed payment flow.
+      escrow_contract_address: sourceDefaults.escrowContract,
+      quote_selector: contractOverrides?.quote_selector ?? sourceDefaults.quoteSelector,
+      fulfillment_verifier: contractOverrides?.fulfillment_verifier ?? {
+        account: sourceDefaults.fulfillmentVerifierAccount,
+        endpoint: sourceDefaults.fulfillmentVerifierEndpoint
+      },
+      fulfillment_proxy: destDefaults.fulfillmentProxy,
+      ...params.settlerRequirements ? { settler_requirements: params.settlerRequirements } : {}
+      // No sender_auth — CreateQuoteRequest has no such field; it is supplied at
+      // award time, not quote time.
+    };
+  }
+};
+
+// src/cli/quote-status.ts
+var program = new import_commander.Command();
+program.name("quote-status").description("Fetch the status of a quote-request batch (no signing required)").version("1.0.0").argument("<quoteRequestId>", "The quote_request_id (qr_...) returned by request-quote").option("--gateway <url>", "Payment gateway URL", defaultGateway).addHelpText("after", `
+Example:
+  quote-status --gateway http://localhost:8080 qr_019f27b9-420d-7353-8263-0cf310670a77
+
+Status values: collecting | ready | awarded | expired
+
+Output:
+  Response JSON  -> stdout (for parsing/automation, e.g. | jq)`).action(async (quoteRequestId, options) => {
+  try {
+    const client = new PaymentGatewayClient2({ BASE: options.gateway });
+    const response = await client.quoteRequests.getQuoteRequestStatus({ quoteRequestId });
+    console.log(JSON.stringify(response, null, 2));
+    process.exit(0);
+  } 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));
+    }
+    process.exit(1);
+  }
+});
+program.parse();
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/