@atumlabs/mppx-atum-escrow 0.1.1 → 0.3.0

package/dist/chunk-Z3AUNEU5.js

@@ -0,0 +1,2645 @@
+import { createRequire as __atumCreateRequire } from 'module'; const require = __atumCreateRequire(import.meta.url);
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../contracts/evm/escrow-encoding/typescript/dist/payment-id.js
+var require_payment_id = __commonJS({
+  "../contracts/evm/escrow-encoding/typescript/dist/payment-id.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.computePaymentId = computePaymentId;
+    exports.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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.generateNonce = generateNonce;
+    var ethers_1 = __require("ethers");
+    function generateNonce() {
+      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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.REFUND_WITNESS_TYPES = exports.RELEASE_WITNESS_TYPES = exports.RESERVE_WITNESS_TYPES = exports.PERMIT_WITNESS_TYPES_V2 = exports.PERMIT_WITNESS_TYPES = void 0;
+    exports.createPermit2Domain = createPermit2Domain;
+    exports.createEscrowDomain = createEscrowDomain;
+    exports.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" }
+      ]
+    };
+    exports.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
+      };
+    }
+    exports.RESERVE_WITNESS_TYPES = {
+      ReserveWitness: [
+        { name: "paymentId", type: "bytes32" },
+        { name: "settler", type: "address" }
+      ]
+    };
+    exports.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" }
+      ]
+    };
+    exports.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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ESCROW_V2_ABI_JSON = exports.ESCROW_V3_ABI_JSON = exports.ESCROW_ABI_JSON = exports.ESCROW_ABI = void 0;
+    exports.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)"
+    ];
+    exports.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"
+      }
+    ];
+    exports.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"
+      }
+    ];
+    exports.ESCROW_V2_ABI_JSON = exports.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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PERMIT2_CONTRACT_ADDRESS = void 0;
+    exports.createPermitWitnessTransferFromPrehash = createPermitWitnessTransferFromPrehash;
+    exports.hashPermitWitnessTransferFrom = hashPermitWitnessTransferFrom;
+    var ethers_1 = __require("ethers");
+    var permit_types_1 = require_permit_types();
+    exports.PERMIT2_CONTRACT_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+    function createPermitWitnessTransferFromPrehash(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 hashPermitWitnessTransferFrom(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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PERMIT2_CONTRACT_ADDRESS = exports.hashPermitWitnessTransferFrom = exports.createPermitWitnessTransferFromPrehash = exports.computeReserveDigest = exports.ESCROW_V3_ABI_JSON = exports.ESCROW_V2_ABI_JSON = exports.ESCROW_ABI_JSON = exports.ESCROW_ABI = exports.REFUND_WITNESS_TYPES = exports.RELEASE_WITNESS_TYPES = exports.RESERVE_WITNESS_TYPES = exports.createEscrowDomain = exports.createPermit2Domain = exports.PERMIT_WITNESS_TYPES_V2 = exports.PERMIT_WITNESS_TYPES = exports.generateNonce = exports.computePaymentIdV2 = exports.computePaymentId = void 0;
+    var payment_id_1 = require_payment_id();
+    Object.defineProperty(exports, "computePaymentId", { enumerable: true, get: function() {
+      return payment_id_1.computePaymentId;
+    } });
+    Object.defineProperty(exports, "computePaymentIdV2", { enumerable: true, get: function() {
+      return payment_id_1.computePaymentIdV2;
+    } });
+    var nonce_generator_1 = require_nonce_generator();
+    Object.defineProperty(exports, "generateNonce", { enumerable: true, get: function() {
+      return nonce_generator_1.generateNonce;
+    } });
+    var permit_types_1 = require_permit_types();
+    Object.defineProperty(exports, "PERMIT_WITNESS_TYPES", { enumerable: true, get: function() {
+      return permit_types_1.PERMIT_WITNESS_TYPES;
+    } });
+    Object.defineProperty(exports, "PERMIT_WITNESS_TYPES_V2", { enumerable: true, get: function() {
+      return permit_types_1.PERMIT_WITNESS_TYPES_V2;
+    } });
+    Object.defineProperty(exports, "createPermit2Domain", { enumerable: true, get: function() {
+      return permit_types_1.createPermit2Domain;
+    } });
+    Object.defineProperty(exports, "createEscrowDomain", { enumerable: true, get: function() {
+      return permit_types_1.createEscrowDomain;
+    } });
+    Object.defineProperty(exports, "RESERVE_WITNESS_TYPES", { enumerable: true, get: function() {
+      return permit_types_1.RESERVE_WITNESS_TYPES;
+    } });
+    Object.defineProperty(exports, "RELEASE_WITNESS_TYPES", { enumerable: true, get: function() {
+      return permit_types_1.RELEASE_WITNESS_TYPES;
+    } });
+    Object.defineProperty(exports, "REFUND_WITNESS_TYPES", { enumerable: true, get: function() {
+      return permit_types_1.REFUND_WITNESS_TYPES;
+    } });
+    var escrow_abi_1 = require_escrow_abi();
+    Object.defineProperty(exports, "ESCROW_ABI", { enumerable: true, get: function() {
+      return escrow_abi_1.ESCROW_ABI;
+    } });
+    Object.defineProperty(exports, "ESCROW_ABI_JSON", { enumerable: true, get: function() {
+      return escrow_abi_1.ESCROW_ABI_JSON;
+    } });
+    Object.defineProperty(exports, "ESCROW_V2_ABI_JSON", { enumerable: true, get: function() {
+      return escrow_abi_1.ESCROW_V2_ABI_JSON;
+    } });
+    Object.defineProperty(exports, "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(exports, "computeReserveDigest", { enumerable: true, get: function() {
+      return reserve_encoder_1.computeReserveDigest;
+    } });
+    var deposit_encoder_1 = require_deposit_encoder();
+    Object.defineProperty(exports, "createPermitWitnessTransferFromPrehash", { enumerable: true, get: function() {
+      return deposit_encoder_1.createPermitWitnessTransferFromPrehash;
+    } });
+    Object.defineProperty(exports, "hashPermitWitnessTransferFrom", { enumerable: true, get: function() {
+      return deposit_encoder_1.hashPermitWitnessTransferFrom;
+    } });
+    Object.defineProperty(exports, "PERMIT2_CONTRACT_ADDRESS", { enumerable: true, get: function() {
+      return deposit_encoder_1.PERMIT2_CONTRACT_ADDRESS;
+    } });
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/types.js
+var require_types = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/utils.js
+var require_utils = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.REQUEST_ID_DOMAIN = exports.SOLANA_REPLAY_SLOTS = exports.PERMIT_NONCE_DOMAIN = exports.REPLAY_HORIZON_SECS = void 0;
+    exports.resolvePermitDeadline = resolvePermitDeadline;
+    exports.generatePermitNonce = generatePermitNonce;
+    exports.resolvePermitNonce = resolvePermitNonce;
+    exports.canonicalDepositor = canonicalDepositor;
+    exports.deterministicPermitNonce = deterministicPermitNonce;
+    exports.deterministicSolanaNonce = deterministicSolanaNonce;
+    exports.deterministicRequestId = deterministicRequestId2;
+    exports.sameAddress = sameAddress2;
+    exports.assertKeyMatchesSender = assertKeyMatchesSender;
+    exports.assertToken = assertToken;
+    exports.assertAmountMatches = assertAmountMatches;
+    exports.assertFresh = assertFresh;
+    exports.assertSpender = assertSpender;
+    exports.assertWitnessRoles = assertWitnessRoles;
+    exports.assertRolePairComplete = assertRolePairComplete;
+    exports.nowSec = nowSec;
+    var ethers_1 = __require("ethers");
+    exports.REPLAY_HORIZON_SECS = 128;
+    function resolvePermitDeadline(deadline) {
+      return BigInt(deadline);
+    }
+    function generatePermitNonce() {
+      const rand = new Uint32Array(1);
+      globalThis.crypto.getRandomValues(rand);
+      return (BigInt(Date.now()) << 32n) + BigInt(rand[0]);
+    }
+    function resolvePermitNonce(nonce) {
+      return BigInt(nonce);
+    }
+    exports.PERMIT_NONCE_DOMAIN = "atum-permit:v1:";
+    exports.SOLANA_REPLAY_SLOTS = 235n;
+    var SOLANA_BUCKET_BITS = 17n;
+    function canonicalDepositor(depositor) {
+      const lower = depositor.toLowerCase();
+      return lower.startsWith("0x") ? lower : depositor;
+    }
+    function permitNonceSeed(requestId, depositor) {
+      if (!requestId) {
+        throw new Error("sender_auth: request_id is required to derive a deterministic permit nonce");
+      }
+      return BigInt((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)(`${exports.PERMIT_NONCE_DOMAIN}${requestId}:${canonicalDepositor(depositor)}`)));
+    }
+    function deterministicPermitNonce(params) {
+      return permitNonceSeed(params.requestId, params.depositor);
+    }
+    function deterministicSolanaNonce(params) {
+      const seed = permitNonceSeed(params.requestId, params.depositor);
+      const slot = seed % exports.SOLANA_REPLAY_SLOTS;
+      const bucket = (seed >> 8n) % (1n << SOLANA_BUCKET_BITS);
+      return bucket << 32n | slot;
+    }
+    exports.REQUEST_ID_DOMAIN = "atum-request:v1:";
+    function deterministicRequestId2(params) {
+      if (!params.anchor) {
+        throw new Error("sender_auth: a per-intent anchor is required to derive a deterministic request_id (a random one would silently break idempotency and let a retry double-charge)");
+      }
+      if (!params.account) {
+        throw new Error("sender_auth: account is required to derive a deterministic request_id");
+      }
+      if (!/^[A-Za-z0-9_-]*$/.test(params.prefix)) {
+        throw new Error(`sender_auth: request_id prefix must contain only letters, digits, '_' or '-' (got ${JSON.stringify(params.prefix)})`);
+      }
+      const digest = (0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)(`${exports.REQUEST_ID_DOMAIN}${params.anchor}:${canonicalDepositor(params.account)}`));
+      return `${params.prefix}${digest.slice(2, 26)}`;
+    }
+    function sameAddress2(a, b) {
+      if (a.startsWith("0x") && b.startsWith("0x")) {
+        return a.toLowerCase() === b.toLowerCase();
+      }
+      return a === b;
+    }
+    function assertKeyMatchesSender(matches, sender, derived) {
+      if (!matches) {
+        throw new Error(`sender_auth: private key derives ${derived}, not the expected sender ${sender}`);
+      }
+    }
+    function assertToken(token, sourceAsset, normalize) {
+      if (!sameAddress2(token, normalize(sourceAsset))) {
+        throw new Error("sender_auth: permit token does not match the source asset");
+      }
+    }
+    function assertAmountMatches(amount, maxSourceAmount) {
+      if (BigInt(amount) !== BigInt(maxSourceAmount)) {
+        throw new Error("sender_auth: permit amount does not match max_source_amount");
+      }
+    }
+    function assertFresh(deadlineSec, nowSec2) {
+      if (deadlineSec <= nowSec2) {
+        throw new Error("sender_auth: permit deadline is not in the future");
+      }
+    }
+    function assertSpender(spender, escrow, normalize) {
+      if (!sameAddress2(spender, normalize(escrow))) {
+        throw new Error("sender_auth: permit spender is not the source escrow");
+      }
+    }
+    function assertWitnessRoles(reserver, releaser, expectedReserver, expectedReleaser, normalize) {
+      if (!sameAddress2(reserver, normalize(expectedReserver)) || !sameAddress2(releaser, normalize(expectedReleaser))) {
+        throw new Error("sender_auth: deposit witness roles do not match the challenge");
+      }
+    }
+    function assertRolePairComplete(reserver, releaser) {
+      if (reserver === void 0 !== (releaser === void 0)) {
+        throw new Error("sender_auth: reserver and releaser must be supplied together");
+      }
+    }
+    function nowSec() {
+      return Math.floor(Date.now() / 1e3);
+    }
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/chain-id.js
+var require_chain_id = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/chain-id.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TRON_PERMIT2_FALLBACKS = exports.TRON_CHAIN_IDS = void 0;
+    exports.namespaceOf = namespaceOf2;
+    exports.evmChainId = evmChainId;
+    exports.tronNumericChainId = tronNumericChainId;
+    exports.resolveTronPermit2 = resolveTronPermit22;
+    exports.clusterIdFromName = clusterIdFromName;
+    function namespaceOf2(network) {
+      return network.split(":")[0];
+    }
+    function evmChainId(network) {
+      const match = /^eip155:([0-9]+)$/.exec(network);
+      if (!match) {
+        throw new Error(`sender_auth: expected an eip155 network, got ${network}`);
+      }
+      return Number(match[1]);
+    }
+    exports.TRON_CHAIN_IDS = {
+      mainnet: 728126428,
+      shasta: 2494104990
+    };
+    function tronNumericChainId(network) {
+      const cluster = network.split(":")[1];
+      const id = exports.TRON_CHAIN_IDS[cluster ?? ""];
+      if (id === void 0) {
+        throw new Error(`sender_auth: unsupported Tron network '${network}'`);
+      }
+      return id;
+    }
+    exports.TRON_PERMIT2_FALLBACKS = {
+      "tron:mainnet": "TJhMXTHQHeQyMD7TcKQFqAePNgG4b31H9m",
+      "tron:shasta": "TPUqJPASUn1zLvbLBgRZ5pBYrx7WSe5ahp"
+    };
+    function resolveTronPermit22(network) {
+      const resolved = exports.TRON_PERMIT2_FALLBACKS[network];
+      if (!resolved) {
+        throw new Error(`sender_auth: no Permit2 address known for Tron network '${network}'`);
+      }
+      return resolved;
+    }
+    function clusterIdFromName(name) {
+      const encoded = new TextEncoder().encode(name);
+      if (encoded.length > 32) {
+        throw new Error(`sender_auth: Solana cluster name too long (${encoded.length} > 32 bytes): ${name}`);
+      }
+      const out = new Uint8Array(32);
+      out.set(encoded);
+      return out;
+    }
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/errors.js
+var require_errors = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/errors.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SignerMismatchError = exports.RecoveryFailedError = exports.MalformedPrehashError = void 0;
+    var MalformedPrehashError = class extends Error {
+      constructor(message = "sender_auth: malformed message_prehash") {
+        super(message);
+        this.name = "MalformedPrehashError";
+      }
+    };
+    exports.MalformedPrehashError = MalformedPrehashError;
+    var RecoveryFailedError = class extends Error {
+      constructor(message = "sender_auth: could not recover a signer from the signed message") {
+        super(message);
+        this.name = "RecoveryFailedError";
+      }
+    };
+    exports.RecoveryFailedError = RecoveryFailedError;
+    var SignerMismatchError = class extends Error {
+      constructor(message = "sender_auth: recovered signer does not match source.account") {
+        super(message);
+        this.name = "SignerMismatchError";
+      }
+    };
+    exports.SignerMismatchError = SignerMismatchError;
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/adapters/evm.js
+var require_evm = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/adapters/evm.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.evmAdapter = void 0;
+    var ethers_1 = __require("ethers");
+    var evm_escrow_encoding_1 = require_dist();
+    var utils_js_1 = require_utils();
+    var errors_js_1 = require_errors();
+    var chain_id_js_1 = require_chain_id();
+    exports.evmAdapter = {
+      async buildAuthMessage({ sourceAsset, maxSourceAmount, sourceDefaults, deadline, nonce }) {
+        if (nonce === void 0) {
+          throw new Error("sender_auth: buildAuthMessage requires an explicit nonce \u2014 derive it deterministically from a stable request id (e.g. an order id) so retries reproduce the same permit; pass generatePermitNonce() only for genuinely one-shot builds");
+        }
+        if (deadline === void 0) {
+          throw new Error("sender_auth: buildAuthMessage requires an explicit permit deadline (absolute Unix seconds) \u2014 the low-level builder does not default it; derive it from the payment's fulfillment/settlement deadline in the calling layer (pgc/mppx)");
+        }
+        const sourceChainId = sourceAsset.split("/")[0];
+        const chainIdNum = parseInt(sourceChainId.split(":")[1]);
+        const tokenAddress = sourceAsset.split("/")[1].split(":")[1];
+        const permitParams = {
+          chainId: chainIdNum,
+          verifyingContract: evm_escrow_encoding_1.PERMIT2_CONTRACT_ADDRESS,
+          token: tokenAddress,
+          amount: maxSourceAmount,
+          spender: sourceDefaults.escrowContract,
+          nonce: (0, utils_js_1.resolvePermitNonce)(nonce),
+          deadline: (0, utils_js_1.resolvePermitDeadline)(deadline),
+          reserver: sourceDefaults.quoteSelector,
+          releaser: sourceDefaults.fulfillmentVerifierAccount
+        };
+        const messagePrehash = (0, evm_escrow_encoding_1.createPermitWitnessTransferFromPrehash)(permitParams);
+        const messageHash = (0, evm_escrow_encoding_1.hashPermitWitnessTransferFrom)(messagePrehash);
+        return { messageScheme: "EVM_PERMIT2", messageHash, messagePrehash: JSON.stringify(messagePrehash) };
+      },
+      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 prehashDigest = (0, evm_escrow_encoding_1.hashPermitWitnessTransferFrom)(prehash);
+        if (prehashDigest.toLowerCase() !== signedMessage.message.toLowerCase()) {
+          throw new Error(`EVM adapter sign(): message_prehash implies digest ${prehashDigest} but message is ${signedMessage.message}`);
+        }
+        const wallet = new ethers_1.Wallet(privateKey);
+        return wallet.signTypedData(prehash.domain, prehash.types, prehash.message);
+      },
+      recoverSigner(signed, source) {
+        let recovered;
+        try {
+          recovered = (0, ethers_1.recoverAddress)(signed.message, signed.signature);
+        } catch (e) {
+          throw new errors_js_1.RecoveryFailedError(`sender_auth: could not recover a signer: ${e.message}`);
+        }
+        if (!(0, utils_js_1.sameAddress)(recovered, source.account)) {
+          throw new errors_js_1.SignerMismatchError(`sender_auth: recovered ${recovered}, not source.account`);
+        }
+        return source.account;
+      },
+      recoverAndVerify(signed, source, expected) {
+        let canonical;
+        let msg;
+        try {
+          msg = JSON.parse(signed.message_prehash).message;
+          canonical = (0, evm_escrow_encoding_1.createPermitWitnessTransferFromPrehash)({
+            chainId: (0, chain_id_js_1.evmChainId)(source.network),
+            verifyingContract: evm_escrow_encoding_1.PERMIT2_CONTRACT_ADDRESS,
+            token: msg.permitted.token,
+            amount: msg.permitted.amount,
+            spender: msg.spender,
+            nonce: BigInt(msg.nonce),
+            deadline: BigInt(msg.deadline),
+            reserver: msg.witness.reserver,
+            releaser: msg.witness.releaser
+          });
+        } catch {
+          throw new errors_js_1.MalformedPrehashError();
+        }
+        let recovered;
+        try {
+          recovered = (0, ethers_1.verifyTypedData)(canonical.domain, canonical.types, canonical.message, signed.signature);
+        } catch {
+          throw new Error("sender_auth: deposit signature does not recover to source.account");
+        }
+        if (!(0, utils_js_1.sameAddress)(recovered, source.account)) {
+          throw new Error("sender_auth: deposit signature does not recover to source.account");
+        }
+        const deadlineSec = Number(msg.deadline);
+        (0, utils_js_1.assertToken)(msg.permitted.token, source.asset, (a) => a);
+        (0, utils_js_1.assertAmountMatches)(msg.permitted.amount, expected.maxSourceAmount);
+        (0, utils_js_1.assertFresh)(deadlineSec, expected.nowSec ?? (0, utils_js_1.nowSec)());
+        if (expected.escrowContract !== void 0) {
+          (0, utils_js_1.assertSpender)(msg.spender, expected.escrowContract, (a) => a);
+        }
+        (0, utils_js_1.assertRolePairComplete)(expected.reserver, expected.releaser);
+        if (expected.reserver !== void 0 && expected.releaser !== void 0) {
+          (0, utils_js_1.assertWitnessRoles)(msg.witness.reserver, msg.witness.releaser, expected.reserver, expected.releaser, (a) => a);
+        }
+        return {
+          amount: msg.permitted.amount,
+          deadlineSec,
+          permit: {
+            scheme: "EVM_PERMIT2",
+            token: msg.permitted.token,
+            amount: msg.permitted.amount,
+            deadlineSec,
+            reserver: msg.witness.reserver,
+            releaser: msg.witness.releaser,
+            spender: msg.spender
+          }
+        };
+      }
+    };
+  }
+});
+
+// ../contracts/tvm/escrow-encoding/typescript/dist/chain-id.js
+var require_chain_id2 = __commonJS({
+  "../contracts/tvm/escrow-encoding/typescript/dist/chain-id.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.maskChainId = maskChainId;
+    function maskChainId(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"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.base58ToHex = base58ToHex;
+    exports.normalizeAddress = normalizeAddress;
+    var ethers_1 = __require("ethers");
+    var bs58_1 = __importDefault(__require("bs58"));
+    var TVM_MAINNET_PREFIX = "41";
+    function base58ToHex(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 normalizeAddress(address) {
+      if (!address) {
+        throw new Error("Empty address");
+      }
+      let hexAddress = address;
+      if (address.startsWith("T")) {
+        hexAddress = base58ToHex(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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.computeReserveDigest = computeReserveDigest;
+    var ethers_1 = __require("ethers");
+    var chain_id_1 = require_chain_id2();
+    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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createTvmPermitWitnessTransferFromPrehash = createTvmPermitWitnessTransferFromPrehash;
+    exports.hashTvmPermitWitnessTransferFrom = hashTvmPermitWitnessTransferFrom;
+    var ethers_1 = __require("ethers");
+    var chain_id_1 = require_chain_id2();
+    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 createTvmPermitWitnessTransferFromPrehash(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 hashTvmPermitWitnessTransferFrom(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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.hashTvmPermitWitnessTransferFrom = exports.createTvmPermitWitnessTransferFromPrehash = exports.computePaymentId = exports.computeReserveDigest = exports.normalizeAddress = exports.base58ToHex = exports.maskChainId = void 0;
+    var chain_id_1 = require_chain_id2();
+    Object.defineProperty(exports, "maskChainId", { enumerable: true, get: function() {
+      return chain_id_1.maskChainId;
+    } });
+    var tron_address_1 = require_tron_address();
+    Object.defineProperty(exports, "base58ToHex", { enumerable: true, get: function() {
+      return tron_address_1.base58ToHex;
+    } });
+    Object.defineProperty(exports, "normalizeAddress", { enumerable: true, get: function() {
+      return tron_address_1.normalizeAddress;
+    } });
+    var reserve_encoder_1 = require_reserve_encoder2();
+    Object.defineProperty(exports, "computeReserveDigest", { enumerable: true, get: function() {
+      return reserve_encoder_1.computeReserveDigest;
+    } });
+    var payment_id_1 = require_payment_id2();
+    Object.defineProperty(exports, "computePaymentId", { enumerable: true, get: function() {
+      return payment_id_1.computePaymentId;
+    } });
+    var deposit_encoder_1 = require_deposit_encoder2();
+    Object.defineProperty(exports, "createTvmPermitWitnessTransferFromPrehash", { enumerable: true, get: function() {
+      return deposit_encoder_1.createTvmPermitWitnessTransferFromPrehash;
+    } });
+    Object.defineProperty(exports, "hashTvmPermitWitnessTransferFrom", { enumerable: true, get: function() {
+      return deposit_encoder_1.hashTvmPermitWitnessTransferFrom;
+    } });
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/adapters/tron.js
+var require_tron = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/adapters/tron.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.tronAdapter = void 0;
+    var ethers_1 = __require("ethers");
+    var tvm_escrow_encoding_1 = require_dist2();
+    var utils_js_1 = require_utils();
+    var errors_js_1 = require_errors();
+    var chain_id_js_1 = require_chain_id();
+    exports.tronAdapter = {
+      async buildAuthMessage({ sourceAsset, maxSourceAmount, sourceDefaults, deadline, nonce }) {
+        if (nonce === void 0) {
+          throw new Error("sender_auth: buildAuthMessage requires an explicit nonce \u2014 derive it deterministically from a stable request id (e.g. an order id) so retries reproduce the same permit; pass generatePermitNonce() only for genuinely one-shot builds");
+        }
+        if (deadline === void 0) {
+          throw new Error("sender_auth: buildAuthMessage requires an explicit permit deadline (absolute Unix seconds) \u2014 the low-level builder does not default it; derive it from the payment's fulfillment/settlement deadline in the calling layer (pgc/mppx)");
+        }
+        const sourceChainId = sourceAsset.split("/")[0];
+        const tokenAddress = sourceAsset.split("/")[1].split(":")[1];
+        const permit2Address = sourceDefaults.permit2Contract ?? (0, chain_id_js_1.resolveTronPermit2)(sourceChainId);
+        const tvmParams = {
+          chainId: (0, chain_id_js_1.tronNumericChainId)(sourceChainId),
+          permit2Address,
+          tokenAddress,
+          amount: maxSourceAmount,
+          spenderAddress: sourceDefaults.escrowContract,
+          nonce: (0, utils_js_1.resolvePermitNonce)(nonce),
+          deadline: (0, utils_js_1.resolvePermitDeadline)(deadline),
+          reserverAddress: sourceDefaults.quoteSelector,
+          releaserAddress: sourceDefaults.fulfillmentVerifierAccount
+        };
+        const messagePrehash = (0, tvm_escrow_encoding_1.createTvmPermitWitnessTransferFromPrehash)(tvmParams);
+        const messageHash = (0, tvm_escrow_encoding_1.hashTvmPermitWitnessTransferFrom)(messagePrehash);
+        return { messageScheme: "EVM_PERMIT2", messageHash, messagePrehash: JSON.stringify(messagePrehash) };
+      },
+      // Signs the TIP-712 typed data, not the bare digest, so a signer can inspect the fields it is
+      // authorizing (Turnkey policies read `eth.eip_712.message[...]`).
+      async sign(signedMessage, privateKey) {
+        if (!signedMessage.message_prehash) {
+          throw new Error("Tron adapter sign(): signed_messages[i].message_prehash is required");
+        }
+        const prehash = JSON.parse(signedMessage.message_prehash);
+        const prehashDigest = (0, tvm_escrow_encoding_1.hashTvmPermitWitnessTransferFrom)(prehash);
+        if (prehashDigest.toLowerCase() !== signedMessage.message.toLowerCase()) {
+          throw new Error(`Tron adapter sign(): message_prehash implies digest ${prehashDigest} but message is ${signedMessage.message}`);
+        }
+        const wallet = new ethers_1.Wallet(privateKey.startsWith("0x") ? privateKey : "0x" + privateKey);
+        return wallet.signTypedData(prehash.domain, prehash.types, prehash.message);
+      },
+      recoverSigner(signed, source) {
+        let recovered;
+        try {
+          recovered = (0, ethers_1.recoverAddress)(signed.message, signed.signature);
+        } catch (e) {
+          throw new errors_js_1.RecoveryFailedError(`sender_auth: could not recover a signer: ${e.message}`);
+        }
+        if (!(0, utils_js_1.sameAddress)(recovered, (0, tvm_escrow_encoding_1.normalizeAddress)(source.account))) {
+          throw new errors_js_1.SignerMismatchError(`sender_auth: recovered ${recovered}, not source.account`);
+        }
+        return source.account;
+      },
+      recoverAndVerify(signed, source, expected) {
+        let msg;
+        let digest;
+        try {
+          msg = JSON.parse(signed.message_prehash).message;
+          const canonical = (0, tvm_escrow_encoding_1.createTvmPermitWitnessTransferFromPrehash)({
+            chainId: (0, chain_id_js_1.tronNumericChainId)(source.network),
+            permit2Address: (0, chain_id_js_1.resolveTronPermit2)(source.network),
+            tokenAddress: msg.permitted.token,
+            amount: msg.permitted.amount,
+            spenderAddress: msg.spender,
+            nonce: BigInt(msg.nonce),
+            deadline: BigInt(msg.deadline),
+            reserverAddress: msg.witness.reserver,
+            releaserAddress: msg.witness.releaser
+          });
+          digest = (0, tvm_escrow_encoding_1.hashTvmPermitWitnessTransferFrom)(canonical);
+        } catch {
+          throw new errors_js_1.MalformedPrehashError();
+        }
+        let recovered;
+        try {
+          recovered = (0, ethers_1.recoverAddress)(digest, signed.signature);
+        } catch {
+          throw new Error("sender_auth: deposit signature does not recover to source.account");
+        }
+        if (!(0, utils_js_1.sameAddress)(recovered, (0, tvm_escrow_encoding_1.normalizeAddress)(source.account))) {
+          throw new Error("sender_auth: deposit signature does not recover to source.account");
+        }
+        const deadlineSec = Number(msg.deadline);
+        (0, utils_js_1.assertToken)(msg.permitted.token, source.asset, tvm_escrow_encoding_1.normalizeAddress);
+        (0, utils_js_1.assertAmountMatches)(msg.permitted.amount, expected.maxSourceAmount);
+        (0, utils_js_1.assertFresh)(deadlineSec, expected.nowSec ?? (0, utils_js_1.nowSec)());
+        if (expected.escrowContract !== void 0) {
+          (0, utils_js_1.assertSpender)(msg.spender, expected.escrowContract, tvm_escrow_encoding_1.normalizeAddress);
+        }
+        (0, utils_js_1.assertRolePairComplete)(expected.reserver, expected.releaser);
+        if (expected.reserver !== void 0 && expected.releaser !== void 0) {
+          (0, utils_js_1.assertWitnessRoles)(msg.witness.reserver, msg.witness.releaser, expected.reserver, expected.releaser, tvm_escrow_encoding_1.normalizeAddress);
+        }
+        return {
+          amount: msg.permitted.amount,
+          deadlineSec,
+          permit: {
+            scheme: "EVM_PERMIT2",
+            token: msg.permitted.token,
+            amount: msg.permitted.amount,
+            deadlineSec,
+            reserver: msg.witness.reserver,
+            releaser: msg.witness.releaser,
+            spender: msg.spender
+          }
+        };
+      }
+    };
+  }
+});
+
+// ../contracts/svm/escrow-encoding/typescript/dist/errors.js
+var require_errors2 = __commonJS({
+  "../contracts/svm/escrow-encoding/typescript/dist/errors.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.InvalidHexError = exports.InvalidBase58Error = exports.InvalidPubkeyLengthError = exports.ZeroDepositHashError = exports.ZeroRecipientError = exports.ZeroReleaserError = exports.ZeroReserverError = exports.ZeroAmountError = exports.ZeroMintError = exports.ZeroDepositorError = exports.ZeroPaymentIdError = exports.EncodingError = void 0;
+    var EncodingError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "EncodingError";
+      }
+    };
+    exports.EncodingError = EncodingError;
+    var ZeroPaymentIdError = class extends EncodingError {
+      constructor() {
+        super("payment ID cannot be zero");
+        this.name = "ZeroPaymentIdError";
+      }
+    };
+    exports.ZeroPaymentIdError = ZeroPaymentIdError;
+    var ZeroDepositorError = class extends EncodingError {
+      constructor() {
+        super("depositor cannot be zero");
+        this.name = "ZeroDepositorError";
+      }
+    };
+    exports.ZeroDepositorError = ZeroDepositorError;
+    var ZeroMintError = class extends EncodingError {
+      constructor() {
+        super("mint cannot be zero");
+        this.name = "ZeroMintError";
+      }
+    };
+    exports.ZeroMintError = ZeroMintError;
+    var ZeroAmountError = class extends EncodingError {
+      constructor() {
+        super("amount cannot be zero");
+        this.name = "ZeroAmountError";
+      }
+    };
+    exports.ZeroAmountError = ZeroAmountError;
+    var ZeroReserverError = class extends EncodingError {
+      constructor() {
+        super("reserver cannot be zero");
+        this.name = "ZeroReserverError";
+      }
+    };
+    exports.ZeroReserverError = ZeroReserverError;
+    var ZeroReleaserError = class extends EncodingError {
+      constructor() {
+        super("releaser cannot be zero");
+        this.name = "ZeroReleaserError";
+      }
+    };
+    exports.ZeroReleaserError = ZeroReleaserError;
+    var ZeroRecipientError = class extends EncodingError {
+      constructor() {
+        super("recipient cannot be zero");
+        this.name = "ZeroRecipientError";
+      }
+    };
+    exports.ZeroRecipientError = ZeroRecipientError;
+    var ZeroDepositHashError = class extends EncodingError {
+      constructor() {
+        super("deposit hash cannot be zero");
+        this.name = "ZeroDepositHashError";
+      }
+    };
+    exports.ZeroDepositHashError = ZeroDepositHashError;
+    var InvalidPubkeyLengthError = class extends EncodingError {
+      constructor() {
+        super("invalid pubkey length: expected 32 bytes");
+        this.name = "InvalidPubkeyLengthError";
+      }
+    };
+    exports.InvalidPubkeyLengthError = InvalidPubkeyLengthError;
+    var InvalidBase58Error = class extends EncodingError {
+      constructor() {
+        super("invalid base58 encoding");
+        this.name = "InvalidBase58Error";
+      }
+    };
+    exports.InvalidBase58Error = InvalidBase58Error;
+    var InvalidHexError = class extends EncodingError {
+      constructor() {
+        super("invalid hex encoding");
+        this.name = "InvalidHexError";
+      }
+    };
+    exports.InvalidHexError = InvalidHexError;
+  }
+});
+
+// ../contracts/svm/escrow-encoding/typescript/dist/pubkey.js
+var require_pubkey = __commonJS({
+  "../contracts/svm/escrow-encoding/typescript/dist/pubkey.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Pubkey = void 0;
+    var bs58_1 = __importDefault(__require("bs58"));
+    var errors_1 = require_errors2();
+    var Pubkey = 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]);
+      }
+    };
+    exports.Pubkey = Pubkey;
+  }
+});
+
+// ../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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.toBig = exports.shrSL = exports.shrSH = exports.rotrSL = exports.rotrSH = exports.rotrBL = exports.rotrBH = exports.rotr32L = exports.rotr32H = exports.rotlSL = exports.rotlSH = exports.rotlBL = exports.rotlBH = exports.add5L = exports.add5H = exports.add4L = exports.add4H = exports.add3L = exports.add3H = void 0;
+    exports.add = add;
+    exports.fromBig = fromBig;
+    exports.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);
+    exports.toBig = toBig;
+    var shrSH = (h, _l, s) => h >>> s;
+    exports.shrSH = shrSH;
+    var shrSL = (h, l, s) => h << 32 - s | l >>> s;
+    exports.shrSL = shrSL;
+    var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+    exports.rotrSH = rotrSH;
+    var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+    exports.rotrSL = rotrSL;
+    var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+    exports.rotrBH = rotrBH;
+    var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+    exports.rotrBL = rotrBL;
+    var rotr32H = (_h, l) => l;
+    exports.rotr32H = rotr32H;
+    var rotr32L = (h, _l) => h;
+    exports.rotr32L = rotr32L;
+    var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+    exports.rotlSH = rotlSH;
+    var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+    exports.rotlSL = rotlSL;
+    var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+    exports.rotlBH = rotlBH;
+    var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+    exports.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);
+    exports.add3L = add3L;
+    var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+    exports.add3H = add3H;
+    var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+    exports.add4L = add4L;
+    var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+    exports.add4H = add4H;
+    var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+    exports.add5L = add5L;
+    var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+    exports.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
+    };
+    exports.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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.crypto = void 0;
+    var nc = __require("crypto");
+    exports.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_utils2 = __commonJS({
+  "../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.Hash = exports.nextTick = exports.swap32IfBE = exports.byteSwapIfBE = exports.swap8IfBE = exports.isLE = void 0;
+    exports.isBytes = isBytes;
+    exports.anumber = anumber;
+    exports.abytes = abytes;
+    exports.ahash = ahash;
+    exports.aexists = aexists;
+    exports.aoutput = aoutput;
+    exports.u8 = u8;
+    exports.u32 = u32;
+    exports.clean = clean;
+    exports.createView = createView;
+    exports.rotr = rotr;
+    exports.rotl = rotl;
+    exports.byteSwap = byteSwap;
+    exports.byteSwap32 = byteSwap32;
+    exports.bytesToHex = bytesToHex;
+    exports.hexToBytes = hexToBytes;
+    exports.asyncLoop = asyncLoop;
+    exports.utf8ToBytes = utf8ToBytes;
+    exports.bytesToUtf8 = bytesToUtf8;
+    exports.toBytes = toBytes;
+    exports.kdfInputToBytes = kdfInputToBytes;
+    exports.concatBytes = concatBytes;
+    exports.checkOpts = checkOpts;
+    exports.createHasher = createHasher;
+    exports.createOptHasher = createOptHasher;
+    exports.createXOFer = createXOFer;
+    exports.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;
+    }
+    exports.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;
+    }
+    exports.swap8IfBE = exports.isLE ? (n) => n : (n) => byteSwap(n);
+    exports.byteSwapIfBE = exports.swap8IfBE;
+    function byteSwap32(arr) {
+      for (let i = 0; i < arr.length; i++) {
+        arr[i] = byteSwap(arr[i]);
+      }
+      return arr;
+    }
+    exports.swap32IfBE = exports.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 bytesToHex(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 hexToBytes(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 () => {
+    };
+    exports.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, exports.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 {
+    };
+    exports.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;
+    }
+    exports.wrapConstructor = createHasher;
+    exports.wrapConstructorWithOpts = createOptHasher;
+    exports.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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.shake256 = exports.shake128 = exports.keccak_512 = exports.keccak_384 = exports.keccak_256 = exports.keccak_224 = exports.sha3_512 = exports.sha3_384 = exports.sha3_256 = exports.sha3_224 = exports.Keccak = void 0;
+    exports.keccakP = keccakP;
+    var _u64_ts_1 = require_u64();
+    var utils_ts_1 = require_utils2();
+    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;
+      }
+    };
+    exports.Keccak = Keccak;
+    var gen = (suffix, blockLen, outputLen) => (0, utils_ts_1.createHasher)(() => new Keccak(blockLen, suffix, outputLen));
+    exports.sha3_224 = (() => gen(6, 144, 224 / 8))();
+    exports.sha3_256 = (() => gen(6, 136, 256 / 8))();
+    exports.sha3_384 = (() => gen(6, 104, 384 / 8))();
+    exports.sha3_512 = (() => gen(6, 72, 512 / 8))();
+    exports.keccak_224 = (() => gen(1, 144, 224 / 8))();
+    exports.keccak_256 = (() => gen(1, 136, 256 / 8))();
+    exports.keccak_384 = (() => gen(1, 104, 384 / 8))();
+    exports.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));
+    exports.shake128 = (() => genShake(31, 168, 128 / 8))();
+    exports.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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.encodeU64LE = encodeU64LE;
+    exports.keccak256 = keccak256;
+    exports.stringToBytes = stringToBytes;
+    exports.isZeroBytes32 = isZeroBytes32;
+    var sha3_1 = require_sha3();
+    function encodeU64LE(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 keccak256(...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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.computeDepositHash = computeDepositHash;
+    var encoding_utils_1 = require_encoding_utils();
+    var escrow_domain_1 = require_escrow_domain();
+    var errors_1 = require_errors2();
+    function computeDepositHash(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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.computeReserveHash = computeReserveHash;
+    var encoding_utils_1 = require_encoding_utils();
+    var escrow_domain_1 = require_escrow_domain();
+    var errors_1 = require_errors2();
+    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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.computeReleaseHash = computeReleaseHash;
+    var encoding_utils_1 = require_encoding_utils();
+    var escrow_domain_1 = require_escrow_domain();
+    var errors_1 = require_errors2();
+    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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.computeRefundHash = computeRefundHash;
+    var encoding_utils_1 = require_encoding_utils();
+    var escrow_domain_1 = require_escrow_domain();
+    var errors_1 = require_errors2();
+    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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MAX_VALID_SLOT = exports.REPLAY_SLOTS = void 0;
+    exports.generateNonce = generateNonce;
+    var crypto_1 = __require("crypto");
+    exports.REPLAY_SLOTS = 235;
+    exports.MAX_VALID_SLOT = exports.REPLAY_SLOTS - 1;
+    var NONCE_BUCKET_MASK = 131071;
+    var NONCE_BUCKET_SHIFT = 32n;
+    function generateNonce() {
+      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 >= exports.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"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MAX_VALID_SLOT = exports.REPLAY_SLOTS = exports.generateNonce = exports.computeRefundHash = exports.computeReleaseHash = exports.computeReserveHash = exports.computeDepositHash = exports.InvalidHexError = exports.InvalidBase58Error = exports.InvalidPubkeyLengthError = exports.ZeroDepositHashError = exports.ZeroRecipientError = exports.ZeroReleaserError = exports.ZeroReserverError = exports.ZeroAmountError = exports.ZeroMintError = exports.ZeroDepositorError = exports.ZeroPaymentIdError = exports.EncodingError = exports.escrowDomainPrefixBytes = exports.isZeroBytes32 = exports.stringToBytes = exports.keccak256 = exports.encodeU64LE = exports.Pubkey = void 0;
+    var pubkey_1 = require_pubkey();
+    Object.defineProperty(exports, "Pubkey", { enumerable: true, get: function() {
+      return pubkey_1.Pubkey;
+    } });
+    var encoding_utils_1 = require_encoding_utils();
+    Object.defineProperty(exports, "encodeU64LE", { enumerable: true, get: function() {
+      return encoding_utils_1.encodeU64LE;
+    } });
+    Object.defineProperty(exports, "keccak256", { enumerable: true, get: function() {
+      return encoding_utils_1.keccak256;
+    } });
+    Object.defineProperty(exports, "stringToBytes", { enumerable: true, get: function() {
+      return encoding_utils_1.stringToBytes;
+    } });
+    Object.defineProperty(exports, "isZeroBytes32", { enumerable: true, get: function() {
+      return encoding_utils_1.isZeroBytes32;
+    } });
+    var escrow_domain_1 = require_escrow_domain();
+    Object.defineProperty(exports, "escrowDomainPrefixBytes", { enumerable: true, get: function() {
+      return escrow_domain_1.escrowDomainPrefixBytes;
+    } });
+    var errors_1 = require_errors2();
+    Object.defineProperty(exports, "EncodingError", { enumerable: true, get: function() {
+      return errors_1.EncodingError;
+    } });
+    Object.defineProperty(exports, "ZeroPaymentIdError", { enumerable: true, get: function() {
+      return errors_1.ZeroPaymentIdError;
+    } });
+    Object.defineProperty(exports, "ZeroDepositorError", { enumerable: true, get: function() {
+      return errors_1.ZeroDepositorError;
+    } });
+    Object.defineProperty(exports, "ZeroMintError", { enumerable: true, get: function() {
+      return errors_1.ZeroMintError;
+    } });
+    Object.defineProperty(exports, "ZeroAmountError", { enumerable: true, get: function() {
+      return errors_1.ZeroAmountError;
+    } });
+    Object.defineProperty(exports, "ZeroReserverError", { enumerable: true, get: function() {
+      return errors_1.ZeroReserverError;
+    } });
+    Object.defineProperty(exports, "ZeroReleaserError", { enumerable: true, get: function() {
+      return errors_1.ZeroReleaserError;
+    } });
+    Object.defineProperty(exports, "ZeroRecipientError", { enumerable: true, get: function() {
+      return errors_1.ZeroRecipientError;
+    } });
+    Object.defineProperty(exports, "ZeroDepositHashError", { enumerable: true, get: function() {
+      return errors_1.ZeroDepositHashError;
+    } });
+    Object.defineProperty(exports, "InvalidPubkeyLengthError", { enumerable: true, get: function() {
+      return errors_1.InvalidPubkeyLengthError;
+    } });
+    Object.defineProperty(exports, "InvalidBase58Error", { enumerable: true, get: function() {
+      return errors_1.InvalidBase58Error;
+    } });
+    Object.defineProperty(exports, "InvalidHexError", { enumerable: true, get: function() {
+      return errors_1.InvalidHexError;
+    } });
+    var deposit_encoder_1 = require_deposit_encoder3();
+    Object.defineProperty(exports, "computeDepositHash", { enumerable: true, get: function() {
+      return deposit_encoder_1.computeDepositHash;
+    } });
+    var reserve_encoder_1 = require_reserve_encoder3();
+    Object.defineProperty(exports, "computeReserveHash", { enumerable: true, get: function() {
+      return reserve_encoder_1.computeReserveHash;
+    } });
+    var release_encoder_1 = require_release_encoder();
+    Object.defineProperty(exports, "computeReleaseHash", { enumerable: true, get: function() {
+      return release_encoder_1.computeReleaseHash;
+    } });
+    var refund_encoder_1 = require_refund_encoder();
+    Object.defineProperty(exports, "computeRefundHash", { enumerable: true, get: function() {
+      return refund_encoder_1.computeRefundHash;
+    } });
+    var nonce_generator_1 = require_nonce_generator2();
+    Object.defineProperty(exports, "generateNonce", { enumerable: true, get: function() {
+      return nonce_generator_1.generateNonce;
+    } });
+    Object.defineProperty(exports, "REPLAY_SLOTS", { enumerable: true, get: function() {
+      return nonce_generator_1.REPLAY_SLOTS;
+    } });
+    Object.defineProperty(exports, "MAX_VALID_SLOT", { enumerable: true, get: function() {
+      return nonce_generator_1.MAX_VALID_SLOT;
+    } });
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/adapters/solana.js
+var require_solana = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/adapters/solana.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.solanaAdapter = void 0;
+    var ethers_1 = __require("ethers");
+    var tweetnacl_1 = __importDefault(__require("tweetnacl"));
+    var bs58_1 = __importDefault(__require("bs58"));
+    var solana_escrow_encoding_1 = require_dist3();
+    var utils_js_1 = require_utils();
+    var errors_js_1 = require_errors();
+    var chain_id_js_1 = require_chain_id();
+    var idAddr = (a) => a;
+    function generateSolanaPaymentIdV3(requestId) {
+      return (0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)(requestId));
+    }
+    function hashDeposit(prehash, domain) {
+      return (0, ethers_1.hexlify)((0, solana_escrow_encoding_1.computeDepositHash)({
+        paymentId: (0, ethers_1.getBytes)(prehash.payment_id),
+        depositor: solana_escrow_encoding_1.Pubkey.fromBase58(prehash.depositor),
+        mint: solana_escrow_encoding_1.Pubkey.fromBase58(prehash.mint),
+        amount: BigInt(prehash.amount),
+        reserver: solana_escrow_encoding_1.Pubkey.fromBase58(prehash.reserver),
+        releaser: solana_escrow_encoding_1.Pubkey.fromBase58(prehash.releaser),
+        nonce: BigInt(prehash.nonce),
+        issuedAt: BigInt(prehash.issued_at),
+        deadline: BigInt(prehash.deadline)
+      }, domain));
+    }
+    function domainFrom(defaults) {
+      if (!defaults.escrowContract) {
+        throw new Error("sender_auth: Solana source requires escrowContract (escrow program id) for the deposit-hash domain");
+      }
+      if (!defaults.svmSignatureClusterId || defaults.svmSignatureDomainVersion == null) {
+        throw new Error("sender_auth: Solana source requires svmSignatureClusterId and svmSignatureDomainVersion (V3 escrow domain separation)");
+      }
+      return {
+        clusterId: (0, chain_id_js_1.clusterIdFromName)(defaults.svmSignatureClusterId),
+        signatureDomainVersion: defaults.svmSignatureDomainVersion,
+        programId: solana_escrow_encoding_1.Pubkey.fromBase58(defaults.escrowContract)
+      };
+    }
+    exports.solanaAdapter = {
+      async buildAuthMessage({ sourceAsset, depositor, maxSourceAmount, requestId, sourceDefaults, nonce, solanaClockReader }) {
+        if (!requestId) {
+          throw new Error("sender_auth: request_id is required");
+        }
+        const sourceChainId = sourceAsset.split("/")[0];
+        const tokenMint = sourceAsset.split("/")[1].split(":")[1];
+        const depositNonce = nonce !== void 0 ? BigInt(nonce) : (0, solana_escrow_encoding_1.generateNonce)();
+        if (nonce !== void 0) {
+          if (depositNonce < 0n || depositNonce >= 1n << 64n) {
+            throw new Error("sender_auth: Solana nonce must fit an unsigned 64-bit integer (0 <= nonce < 2^64)");
+          }
+          if ((depositNonce & 0xffn) >= utils_js_1.SOLANA_REPLAY_SLOTS) {
+            throw new Error(`sender_auth: Solana nonce low byte (replay slot = nonce & 0xFF = ${depositNonce & 0xffn}) must be < ${utils_js_1.SOLANA_REPLAY_SLOTS}; slots ${utils_js_1.SOLANA_REPLAY_SLOTS}-255 are reserved`);
+          }
+        }
+        const issuedAt = solanaClockReader ? await solanaClockReader(sourceChainId) : BigInt(Math.floor(Date.now() / 1e3));
+        const deadline = issuedAt + BigInt(utils_js_1.REPLAY_HORIZON_SECS - 8);
+        const paymentId = generateSolanaPaymentIdV3(requestId);
+        const prehash = {
+          payment_id: paymentId,
+          depositor,
+          mint: tokenMint,
+          amount: BigInt(maxSourceAmount).toString(),
+          reserver: sourceDefaults.quoteSelector,
+          releaser: sourceDefaults.fulfillmentVerifierAccount,
+          nonce: depositNonce.toString(),
+          issued_at: issuedAt.toString(),
+          deadline: deadline.toString()
+        };
+        const depositHash = hashDeposit(prehash, domainFrom(sourceDefaults));
+        return { messageScheme: "SOLANA", messageHash: depositHash, messagePrehash: JSON.stringify(prehash) };
+      },
+      async sign(signedMessage, privateKey) {
+        const messageBytes = (0, ethers_1.getBytes)(signedMessage.message);
+        const secretKey = secretKeyFromPrivate(privateKey);
+        const sig = tweetnacl_1.default.sign.detached(messageBytes, secretKey);
+        return "0x" + Buffer.from(sig).toString("hex");
+      },
+      deriveDelegateSigner(privateKey) {
+        return bs58_1.default.encode(tweetnacl_1.default.sign.keyPair.fromSecretKey(secretKeyFromPrivate(privateKey)).publicKey);
+      },
+      recoverSigner(signed, source) {
+        const provided = signed.payload?.delegate_signer;
+        if (provided !== void 0 && provided !== source.account) {
+          throw new errors_js_1.SignerMismatchError(`sender_auth: delegate_signer ${provided} != source.account`);
+        }
+        const signer = provided ?? source.account;
+        let pub;
+        let msg;
+        let sig;
+        try {
+          pub = bs58_1.default.decode(signer);
+          msg = (0, ethers_1.getBytes)(signed.message);
+          sig = (0, ethers_1.getBytes)(signed.signature);
+        } catch {
+          throw new errors_js_1.RecoveryFailedError("sender_auth: malformed Solana pubkey/message/signature encoding");
+        }
+        if (pub.length !== 32 || msg.length !== 32 || sig.length !== 64) {
+          throw new errors_js_1.RecoveryFailedError("sender_auth: Solana pubkey must be 32 bytes, message 32, signature 64");
+        }
+        let ok = false;
+        try {
+          ok = tweetnacl_1.default.sign.detached.verify(msg, sig, pub);
+        } catch {
+          ok = false;
+        }
+        if (!ok) {
+          throw new errors_js_1.SignerMismatchError("sender_auth: ed25519 verification failed");
+        }
+        return source.account;
+      },
+      recoverAndVerify(signed, source, expected) {
+        let prehash;
+        let canonicalHash;
+        try {
+          prehash = JSON.parse(signed.message_prehash);
+          canonicalHash = hashDeposit(prehash, domainFrom(expected));
+        } catch {
+          throw new errors_js_1.MalformedPrehashError();
+        }
+        if (canonicalHash.toLowerCase() !== signed.message.toLowerCase()) {
+          throw new Error("sender_auth: deposit hash does not match the signed message");
+        }
+        const delegateSigner = signed.payload?.delegate_signer;
+        if (!delegateSigner) {
+          throw new Error("sender_auth: Solana credential is missing delegate_signer");
+        }
+        let verified = false;
+        try {
+          verified = tweetnacl_1.default.sign.detached.verify((0, ethers_1.getBytes)(signed.message), (0, ethers_1.getBytes)(signed.signature), bs58_1.default.decode(delegateSigner));
+        } catch {
+          verified = false;
+        }
+        if (!verified || delegateSigner !== source.account || prehash.depositor !== source.account) {
+          throw new Error("sender_auth: deposit signature does not recover to source.account");
+        }
+        const deadlineSec = Number(prehash.deadline);
+        (0, utils_js_1.assertToken)(prehash.mint, source.asset, idAddr);
+        (0, utils_js_1.assertAmountMatches)(prehash.amount, expected.maxSourceAmount);
+        (0, utils_js_1.assertRolePairComplete)(expected.reserver, expected.releaser);
+        if (expected.reserver !== void 0 && expected.releaser !== void 0) {
+          (0, utils_js_1.assertWitnessRoles)(prehash.reserver, prehash.releaser, expected.reserver, expected.releaser, idAddr);
+        }
+        return {
+          amount: prehash.amount,
+          deadlineSec,
+          permit: {
+            scheme: "SOLANA",
+            token: prehash.mint,
+            amount: prehash.amount,
+            deadlineSec,
+            reserver: prehash.reserver,
+            releaser: prehash.releaser,
+            depositor: prehash.depositor
+          }
+        };
+      }
+    };
+    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 tweetnacl_1.default.sign.keyPair.fromSeed(seed).secretKey;
+      }
+      const decoded = bs58_1.default.decode(privateKey);
+      if (decoded.length === 64)
+        return decoded;
+      if (decoded.length === 32)
+        return tweetnacl_1.default.sign.keyPair.fromSeed(decoded).secretKey;
+      throw new Error(`Invalid Solana private key length: expected 32 or 64 bytes, got ${decoded.length}`);
+    }
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/adapters/index.js
+var require_adapters = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/adapters/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getChainAdapter = getChainAdapter;
+    var chain_id_js_1 = require_chain_id();
+    var evm_js_1 = require_evm();
+    var tron_js_1 = require_tron();
+    var solana_js_1 = require_solana();
+    var adapters = {
+      eip155: evm_js_1.evmAdapter,
+      tron: tron_js_1.tronAdapter,
+      solana: solana_js_1.solanaAdapter
+    };
+    function getChainAdapter(caip2) {
+      const adapter = adapters[(0, chain_id_js_1.namespaceOf)(caip2)];
+      if (!adapter) {
+        throw new Error(`sender_auth: unsupported source chain '${caip2}'`);
+      }
+      return adapter;
+    }
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/verify.js
+var require_verify = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/verify.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.verifyPaymentRequest = verifyPaymentRequest;
+    var index_js_1 = require_adapters();
+    function parseSourceAsset(assetIdentifier2) {
+      const parts = assetIdentifier2.split("/");
+      const nsParts = parts[1]?.split(":");
+      if (parts.length < 2 || !nsParts || nsParts.length < 2 || !nsParts[1]) {
+        throw new Error(`sender_auth: invalid source asset "${assetIdentifier2}"`);
+      }
+      return { network: parts[0], asset: nsParts[1] };
+    }
+    function verifyPaymentRequest(request, expected = {}) {
+      const senderAuth = request.sender_auth;
+      if (!senderAuth?.signed_messages?.length) {
+        throw new Error("sender_auth: request has no signed_messages to verify");
+      }
+      if (!request.source) {
+        throw new Error("sender_auth: request has no source");
+      }
+      const requestSource = parseSourceAsset(request.source.asset_identifier);
+      const { sourceAsset, network: networkOverride, maxSourceAmount: amountOverride, ...scheme } = expected;
+      const network = networkOverride ?? requestSource.network;
+      const asset = sourceAsset ?? requestSource.asset;
+      const maxSourceAmount = amountOverride ?? request.max_source_amount ?? "0";
+      const source = { network, asset, account: request.source.account };
+      const perMessage = { ...scheme, maxSourceAmount };
+      const adapter = (0, index_js_1.getChainAdapter)(network);
+      const results = senderAuth.signed_messages.map((m) => adapter.recoverAndVerify(m, source, perMessage));
+      return { results, recoveredAccount: source.account };
+    }
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/signer.js
+var require_signer = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/signer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.localKeySigner = localKeySigner;
+    var index_js_1 = require_adapters();
+    function localKeySigner(network, privateKey) {
+      const adapter = (0, index_js_1.getChainAdapter)(network);
+      return {
+        async sign(signedMessage) {
+          const signature = await adapter.sign(signedMessage, privateKey);
+          const delegateSigner = adapter.deriveDelegateSigner?.(privateKey);
+          return delegateSigner !== void 0 ? { signature, delegateSigner } : { signature };
+        }
+      };
+    }
+  }
+});
+
+// ../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/index.js
+var require_dist4 = __commonJS({
+  "../schemas/declarations/PaymentRequest/v1/bindings/typescript/sender-auth/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.localKeySigner = exports.SignerMismatchError = exports.RecoveryFailedError = exports.MalformedPrehashError = exports.verifyPaymentRequest = exports.getChainAdapter = void 0;
+    __exportStar(require_types(), exports);
+    __exportStar(require_utils(), exports);
+    __exportStar(require_chain_id(), exports);
+    var index_js_1 = require_adapters();
+    Object.defineProperty(exports, "getChainAdapter", { enumerable: true, get: function() {
+      return index_js_1.getChainAdapter;
+    } });
+    var verify_js_1 = require_verify();
+    Object.defineProperty(exports, "verifyPaymentRequest", { enumerable: true, get: function() {
+      return verify_js_1.verifyPaymentRequest;
+    } });
+    var errors_js_1 = require_errors();
+    Object.defineProperty(exports, "MalformedPrehashError", { enumerable: true, get: function() {
+      return errors_js_1.MalformedPrehashError;
+    } });
+    Object.defineProperty(exports, "RecoveryFailedError", { enumerable: true, get: function() {
+      return errors_js_1.RecoveryFailedError;
+    } });
+    Object.defineProperty(exports, "SignerMismatchError", { enumerable: true, get: function() {
+      return errors_js_1.SignerMismatchError;
+    } });
+    var signer_js_1 = require_signer();
+    Object.defineProperty(exports, "localKeySigner", { enumerable: true, get: function() {
+      return signer_js_1.localKeySigner;
+    } });
+  }
+});
+
+// src/internal.ts
+var import_tvm_escrow_encoding = __toESM(require_dist2(), 1);
+var import_payment_request_sender_auth = __toESM(require_dist4(), 1);
+import * as z from "zod/mini";
+import { Method, PaymentRequest as OpaqueCodec } from "mppx";
+var METHOD_NAME = "atum-escrow";
+var INTENT = "charge";
+var INTENT_ID_META_KEY = "atumIntentId";
+var REQUEST_ID_PREFIX = "req_mpp_";
+function chargeRequestId(intentId, account) {
+  return (0, import_payment_request_sender_auth.deterministicRequestId)({ anchor: intentId, account, prefix: REQUEST_ID_PREFIX });
+}
+function intentIdOf(challenge) {
+  const fromMeta = challenge.meta?.[INTENT_ID_META_KEY];
+  if (typeof fromMeta === "string" && fromMeta !== "") {
+    return fromMeta;
+  }
+  if (challenge.opaque === void 0) {
+    return void 0;
+  }
+  let decoded;
+  try {
+    decoded = OpaqueCodec.deserialize(challenge.opaque);
+  } catch {
+    return void 0;
+  }
+  if (typeof decoded !== "object" || decoded === null) {
+    return void 0;
+  }
+  const value = decoded[INTENT_ID_META_KEY];
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+var ChargeRequestSchema = z.object({
+  /** The source chain/token/cap the payer funds from (one option per challenge). */
+  source: z.object({
+    /** CAIP-2 source chain id (e.g. `eip155:8453`, `tron:mainnet`, `solana:<genesis>`). */
+    network: z.string(),
+    /** Source token address (EVM hex or base58). */
+    asset: z.string(),
+    /** Source spend cap (fulfillmentAmount + markup), atomic units — the authoritative `max_source_amount`. */
+    amount: z.string()
+  }),
+  /** The destination/corridor block (the reused x402 `extra`). */
+  extra: z.object({
+    /** Where the merchant receives: CAIP-2 chain, token, and receive address. */
+    destination: z.object({
+      network: z.string(),
+      asset: z.string(),
+      address: z.string()
+    }),
+    /** Exact amount the merchant receives, in atomic units of the destination token. */
+    fulfillmentAmount: z.string(),
+    /** Source-chain escrow contract for this option; the payer's funds lock here. */
+    escrow: z.string(),
+    /** Destination-chain fulfillment-proxy contract. */
+    fulfillmentProxy: z.string(),
+    /** Role address that witnesses the escrow deposit on reservation. */
+    reserver: z.string(),
+    /** Role address that witnesses the escrow release on fulfillment. */
+    releaser: z.string(),
+    /** Endpoint used to verify fulfillment on the source chain. */
+    fulfillmentVerifierEndpoint: z.string(),
+    /** Quote-deadline budget in seconds, relative to signing time. */
+    quoteDeadlineSeconds: z.number(),
+    /** Fulfillment-deadline budget in seconds, relative to signing time. */
+    fulfillmentDeadlineSeconds: z.number(),
+    /** Solana-only: cluster id that domain-separates the deposit authorization. */
+    svmSignatureClusterId: z.optional(z.string()),
+    /**
+     * Solana-only: signature domain version that domain-separates the deposit authorization.
+     * Bounded 1–255 to match the wire schema (a uint8 the escrow's V3 domain uses).
+     */
+    svmSignatureDomainVersion: z.optional(z.number().check(z.gte(1), z.lte(255))),
+    /**
+     * Solana-only: merchant-stamped issue time (epoch seconds). When present, the client
+     * stamps the deposit's `issued_at` from it so the 402 is self-contained (no client RPC).
+     * Digits-only, matching the wire schema — so the client's `BigInt(issuedAt)` can never
+     * throw on a non-numeric value or silently coerce `""`/whitespace to the Unix epoch.
+     */
+    issuedAt: z.optional(z.string().check(z.regex(/^[0-9]+$/)))
+  })
+});
+var CredentialPayloadSchema = z.object({
+  paymentRequest: z.record(z.string(), z.unknown())
+});
+var atumEscrowChargeMethod = Method.from({
+  name: METHOD_NAME,
+  intent: INTENT,
+  schema: {
+    request: ChargeRequestSchema,
+    credential: { payload: CredentialPayloadSchema }
+  }
+});
+function namespaceOf(network) {
+  return network.split(":")[0];
+}
+function assetTypeFor(network) {
+  switch (namespaceOf(network)) {
+    case "eip155":
+      return "erc20";
+    case "tron":
+      return "trc20";
+    case "solana":
+      return "spl";
+    default:
+      throw new Error(`atum-escrow: unsupported network '${network}'`);
+  }
+}
+function assetIdentifier(network, asset) {
+  return `${network}/${assetTypeFor(network)}:${asset}`;
+}
+function sameAddress(a, b) {
+  if (a.startsWith("0x") && b.startsWith("0x")) {
+    return a.toLowerCase() === b.toLowerCase();
+  }
+  return a === b;
+}
+function chainDefaultsFromExtra(extra, network) {
+  return {
+    escrowContract: extra.escrow,
+    quoteSelector: extra.reserver,
+    fulfillmentVerifierAccount: extra.releaser,
+    fulfillmentVerifierEndpoint: extra.fulfillmentVerifierEndpoint,
+    fulfillmentProxy: extra.fulfillmentProxy,
+    // Pin the Tron Permit2 so the adapter signs against the canonical address (the same one
+    // verify() rebuilds against), never leaving it to the adapter's internal fallback. The
+    // address is fixed per-network (not carried on the wire) — see resolveTronPermit2.
+    ...namespaceOf(network) === "tron" ? { permit2Contract: (0, import_payment_request_sender_auth.resolveTronPermit2)(network) } : {},
+    ...extra.svmSignatureClusterId ? { svmSignatureClusterId: extra.svmSignatureClusterId } : {},
+    ...extra.svmSignatureDomainVersion != null ? { svmSignatureDomainVersion: extra.svmSignatureDomainVersion } : {}
+  };
+}
+function contractOverridesFromExtra(network, extra) {
+  if (namespaceOf(network) !== "tron") {
+    return void 0;
+  }
+  return {
+    quote_selector: (0, import_tvm_escrow_encoding.normalizeAddress)(extra.reserver),
+    fulfillment_verifier: {
+      account: (0, import_tvm_escrow_encoding.normalizeAddress)(extra.releaser),
+      endpoint: extra.fulfillmentVerifierEndpoint
+    }
+  };
+}
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS,
+  require_dist,
+  require_dist4 as require_dist2,
+  import_payment_request_sender_auth,
+  METHOD_NAME,
+  INTENT,
+  INTENT_ID_META_KEY,
+  chargeRequestId,
+  intentIdOf,
+  ChargeRequestSchema,
+  CredentialPayloadSchema,
+  atumEscrowChargeMethod,
+  namespaceOf,
+  assetIdentifier,
+  sameAddress,
+  chainDefaultsFromExtra,
+  contractOverridesFromExtra
+};
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/