@sip-protocol/sdk 0.11.1 → 0.12.0

package/dist/browser.js

@@ -5,11 +5,20 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -3148,6 +3157,77 @@ var init_utils2 = __esm({
   }
 });
 
+// src/chains/solana/stealth-signer.ts
+function modL(value) {
+  const reduced = value % ED25519_ORDER;
+  return reduced >= 0n ? reduced : reduced + ED25519_ORDER;
+}
+function signEd25519WithScalar(message, scalar) {
+  const a = modL(bytesToBigIntLE(scalar));
+  if (a === 0n) {
+    throw new Error("Invalid stealth scalar: reduces to zero");
+  }
+  const A = import_ed255194.ed25519.ExtendedPoint.BASE.multiply(a).toRawBytes();
+  const prefix = (0, import_sha5123.sha512)(scalar).slice(32, 64);
+  const r = modL(bytesToBigIntLE((0, import_sha5123.sha512)(new Uint8Array([...prefix, ...message]))));
+  if (r === 0n) {
+    throw new Error("Invalid nonce: reduces to zero");
+  }
+  const R = import_ed255194.ed25519.ExtendedPoint.BASE.multiply(r).toRawBytes();
+  const k = modL(bytesToBigIntLE((0, import_sha5123.sha512)(new Uint8Array([...R, ...A, ...message]))));
+  const S = modL(r + k * a);
+  return new Uint8Array([...R, ...bigIntToBytesLE(S, 32)]);
+}
+function deriveStealthSigner(params) {
+  const {
+    stealthAddress,
+    ephemeralPublicKey,
+    viewingPrivateKey,
+    spendingPrivateKey,
+    version = "2"
+  } = params;
+  const stealthAddressHex = solanaAddressToEd25519PublicKey(stealthAddress);
+  const ephemeralPubKeyHex = solanaAddressToEd25519PublicKey(ephemeralPublicKey);
+  const stealthAddressObj = {
+    address: stealthAddressHex,
+    ephemeralPublicKey: ephemeralPubKeyHex,
+    viewTag: 0
+  };
+  const recovery = version === "1" ? deriveEd25519StealthPrivateKeyV1(stealthAddressObj, spendingPrivateKey, viewingPrivateKey) : deriveEd25519StealthPrivateKey(stealthAddressObj, spendingPrivateKey, viewingPrivateKey);
+  const scalar = (0, import_utils18.hexToBytes)(recovery.privateKey.slice(2));
+  const publicKey = new import_web35.PublicKey(stealthAddress);
+  const expectedPubKeyBytes = publicKey.toBytes();
+  const derivedPubKeyBytes = import_ed255194.ed25519.ExtendedPoint.BASE.multiply(modL(bytesToBigIntLE(scalar))).toRawBytes();
+  if (!derivedPubKeyBytes.every((b, i) => b === expectedPubKeyBytes[i])) {
+    throw new Error(
+      "Stealth key derivation failed: derived scalar does not produce expected public key. This may indicate incorrect spending/viewing keys or corrupted announcement data."
+    );
+  }
+  return {
+    publicKey,
+    signMessage(message) {
+      return signEd25519WithScalar(message, scalar);
+    },
+    signTransaction(transaction) {
+      const message = transaction.serializeMessage();
+      const signature = signEd25519WithScalar(message, scalar);
+      transaction.addSignature(publicKey, Buffer.from(signature));
+    }
+  };
+}
+var import_web35, import_ed255194, import_sha5123, import_utils18;
+var init_stealth_signer = __esm({
+  "src/chains/solana/stealth-signer.ts"() {
+    "use strict";
+    import_web35 = require("@solana/web3.js");
+    import_ed255194 = require("@noble/curves/ed25519");
+    import_sha5123 = require("@noble/hashes/sha512");
+    import_utils18 = require("@noble/hashes/utils");
+    init_stealth2();
+    init_utils();
+  }
+});
+
 // src/chains/solana/scan.ts
 async function scanForPayments(params) {
   const {
@@ -3160,7 +3240,7 @@ async function scanForPayments(params) {
     provider
   } = params;
   const results = [];
-  const memoProgram = new import_web35.PublicKey(MEMO_PROGRAM_ID);
+  const memoProgram = new import_web36.PublicKey(MEMO_PROGRAM_ID);
   try {
     const signatures = await connection.getSignaturesForAddress(
       memoProgram,
@@ -3239,6 +3319,7 @@ async function scanForPayments(params) {
               results.push({
                 stealthAddress: announcement.stealthAddress || "",
                 ephemeralPublicKey: announcement.ephemeralPublicKey,
+                version: announcement.version,
                 amount,
                 mint: transferInfo.mint,
                 tokenSymbol,
@@ -3269,51 +3350,34 @@ async function claimStealthPayment(params) {
     mint,
     version = "2"
   } = params;
-  const stealthPubkeyForBalance = new import_web35.PublicKey(stealthAddress);
+  const stealthPubkeyForBalance = new import_web36.PublicKey(stealthAddress);
   const solBalance = await connection.getBalance(stealthPubkeyForBalance);
   if (BigInt(solBalance) < MIN_SOL_FOR_FEES) {
     throw new Error(
       `Insufficient SOL for transaction fees. Stealth address has ${solBalance} lamports, needs at least ${MIN_SOL_FOR_FEES} lamports (~0.000005 SOL). Fund the stealth address with SOL before claiming.`
     );
   }
-  const stealthAddressHex = solanaAddressToEd25519PublicKey(stealthAddress);
-  const ephemeralPubKeyHex = solanaAddressToEd25519PublicKey(ephemeralPublicKey);
-  const stealthAddressObj = {
-    address: stealthAddressHex,
-    ephemeralPublicKey: ephemeralPubKeyHex,
-    viewTag: 0
-    // Not needed for derivation
-  };
-  const recovery = version === "1" ? deriveEd25519StealthPrivateKeyV1(stealthAddressObj, spendingPrivateKey, viewingPrivateKey) : deriveEd25519StealthPrivateKey(stealthAddressObj, spendingPrivateKey, viewingPrivateKey);
-  const stealthPrivKeyBytes = (0, import_utils19.hexToBytes)(recovery.privateKey.slice(2));
-  const stealthPubkey = new import_web35.PublicKey(stealthAddress);
-  const expectedPubKeyBytes = stealthPubkey.toBytes();
-  const scalarBigInt = bytesToBigIntLE2(stealthPrivKeyBytes);
-  const ED25519_ORDER6 = 2n ** 252n + 27742317777372353535851937790883648493n;
-  let validScalar = scalarBigInt % ED25519_ORDER6;
-  if (validScalar === 0n) validScalar = 1n;
-  const derivedPubKeyBytes = import_ed255194.ed25519.ExtendedPoint.BASE.multiply(validScalar).toRawBytes();
-  if (!derivedPubKeyBytes.every((b, i) => b === expectedPubKeyBytes[i])) {
-    throw new Error(
-      "Stealth key derivation failed: derived private key does not produce expected public key. This may indicate incorrect spending/viewing keys or corrupted announcement data."
-    );
-  }
-  const stealthKeypair = import_web35.Keypair.fromSecretKey(
-    new Uint8Array([...stealthPrivKeyBytes, ...expectedPubKeyBytes])
-  );
+  const stealthSigner = deriveStealthSigner({
+    stealthAddress,
+    ephemeralPublicKey,
+    viewingPrivateKey,
+    spendingPrivateKey,
+    version
+  });
+  const stealthPubkey = new import_web36.PublicKey(stealthAddress);
   const stealthATA = await (0, import_spl_token3.getAssociatedTokenAddress)(
     mint,
     stealthPubkey,
     true
   );
-  const destinationPubkey = new import_web35.PublicKey(destinationAddress);
+  const destinationPubkey = new import_web36.PublicKey(destinationAddress);
   const destinationATA = await (0, import_spl_token3.getAssociatedTokenAddress)(
     mint,
     destinationPubkey
   );
   const stealthAccount = await (0, import_spl_token3.getAccount)(connection, stealthATA);
   const amount = stealthAccount.amount;
-  const transaction = new import_web35.Transaction();
+  const transaction = new import_web36.Transaction();
   transaction.add(
     (0, import_spl_token3.createTransferInstruction)(
       stealthATA,
@@ -3326,7 +3390,7 @@ async function claimStealthPayment(params) {
   transaction.recentBlockhash = blockhash;
   transaction.lastValidBlockHeight = lastValidBlockHeight;
   transaction.feePayer = stealthPubkey;
-  transaction.sign(stealthKeypair);
+  stealthSigner.signTransaction(transaction);
   const txSignature = await connection.sendRawTransaction(
     transaction.serialize(),
     {
@@ -3358,7 +3422,7 @@ async function getStealthBalance(connection, stealthAddress, mint, provider) {
     }
   }
   try {
-    const stealthPubkey = new import_web35.PublicKey(stealthAddress);
+    const stealthPubkey = new import_web36.PublicKey(stealthAddress);
     const ata = await (0, import_spl_token3.getAssociatedTokenAddress)(mint, stealthPubkey, true);
     const account = await (0, import_spl_token3.getAccount)(connection, ata);
     return account.amount;
@@ -3378,25 +3442,17 @@ function detectCluster4(endpoint) {
   }
   return "mainnet-beta";
 }
-function bytesToBigIntLE2(bytes) {
-  let result = 0n;
-  for (let i = bytes.length - 1; i >= 0; i--) {
-    result = result << 8n | BigInt(bytes[i]);
-  }
-  return result;
-}
-var import_web35, import_spl_token3, import_utils19, import_ed255194, MIN_SOL_FOR_FEES;
+var import_web36, import_spl_token3, MIN_SOL_FOR_FEES;
 var init_scan = __esm({
   "src/chains/solana/scan.ts"() {
     "use strict";
-    import_web35 = require("@solana/web3.js");
+    import_web36 = require("@solana/web3.js");
     import_spl_token3 = require("@solana/spl-token");
     init_stealth2();
     init_types();
     init_constants();
     init_utils2();
-    import_utils19 = require("@noble/hashes/utils");
-    import_ed255194 = require("@noble/curves/ed25519");
+    init_stealth_signer();
     MIN_SOL_FOR_FEES = 5000n;
   }
 });
@@ -3444,11 +3500,11 @@ async function fullHistoricalScan(options, recipients, scanOptions = {}, onProgr
   }
   return allPayments;
 }
-var import_web36, StealthScanner;
+var import_web37, StealthScanner;
 var init_stealth_scanner = __esm({
   "src/chains/solana/stealth-scanner.ts"() {
     "use strict";
-    import_web36 = require("@solana/web3.js");
+    import_web37 = require("@solana/web3.js");
     init_stealth2();
     init_types();
     init_constants();
@@ -3519,7 +3575,7 @@ var init_stealth_scanner = __esm({
         let scannedCount = 0;
         let lastSignature;
         let lastSlot;
-        const memoProgram = new import_web36.PublicKey(MEMO_PROGRAM_ID);
+        const memoProgram = new import_web37.PublicKey(MEMO_PROGRAM_ID);
         try {
           const signatures = await this.connection.getSignaturesForAddress(
             memoProgram,
@@ -3587,7 +3643,7 @@ var init_stealth_scanner = __esm({
         }
         this.paymentCallback = onPayment;
         this.errorCallback = onError ?? null;
-        const memoProgram = new import_web36.PublicKey(MEMO_PROGRAM_ID);
+        const memoProgram = new import_web37.PublicKey(MEMO_PROGRAM_ID);
         this.subscriptionId = this.connection.onLogs(
           memoProgram,
           async (logs) => {
@@ -3689,6 +3745,7 @@ var init_stealth_scanner = __esm({
               return {
                 stealthAddress: announcement.stealthAddress || "",
                 ephemeralPublicKey: announcement.ephemeralPublicKey,
+                version: announcement.version,
                 viewTag: viewTagNumber,
                 amount,
                 mint: transferInfo.mint,
@@ -3710,10 +3767,10 @@ var init_stealth_scanner = __esm({
 
 // src/chains/solana/ephemeral-keys.ts
 function generateEphemeralKeypair() {
-  const privateKeyBytes = (0, import_utils21.randomBytes)(32);
+  const privateKeyBytes = (0, import_utils22.randomBytes)(32);
   const publicKeyBytes = import_ed255195.ed25519.getPublicKey(privateKeyBytes);
-  const privateKey = `0x${(0, import_utils21.bytesToHex)(privateKeyBytes)}`;
-  const publicKey = `0x${(0, import_utils21.bytesToHex)(publicKeyBytes)}`;
+  const privateKey = `0x${(0, import_utils22.bytesToHex)(privateKeyBytes)}`;
+  const publicKey = `0x${(0, import_utils22.bytesToHex)(publicKeyBytes)}`;
   const publicKeyBase58 = ed25519PublicKeyToSolanaAddress(publicKey);
   secureWipe(privateKeyBytes);
   return {
@@ -3723,10 +3780,10 @@ function generateEphemeralKeypair() {
   };
 }
 function generateManagedEphemeralKeypair() {
-  const privateKeyBytes = (0, import_utils21.randomBytes)(32);
+  const privateKeyBytes = (0, import_utils22.randomBytes)(32);
   const publicKeyBytes = import_ed255195.ed25519.getPublicKey(privateKeyBytes);
-  const privateKeyHex = `0x${(0, import_utils21.bytesToHex)(privateKeyBytes)}`;
-  const publicKeyHex = `0x${(0, import_utils21.bytesToHex)(publicKeyBytes)}`;
+  const privateKeyHex = `0x${(0, import_utils22.bytesToHex)(privateKeyBytes)}`;
+  const publicKeyHex = `0x${(0, import_utils22.bytesToHex)(publicKeyBytes)}`;
   const publicKeyBase58 = ed25519PublicKeyToSolanaAddress(publicKeyHex);
   let disposed = false;
   const managed = {
@@ -3759,10 +3816,10 @@ function batchGenerateEphemeralKeypairs(options) {
     throw new Error("count cannot exceed 1000 (security limit)");
   }
   const keypairs = [];
-  let entropyState = entropyMixing ? (0, import_utils21.randomBytes)(32) : null;
+  let entropyState = entropyMixing ? (0, import_utils22.randomBytes)(32) : null;
   for (let i = 0; i < count; i++) {
     if (entropyMixing && entropyState) {
-      const extraEntropy = (0, import_utils21.randomBytes)(32);
+      const extraEntropy = (0, import_utils22.randomBytes)(32);
       entropyState = (0, import_sha2566.sha256)(new Uint8Array([...entropyState, ...extraEntropy]));
     }
     keypairs.push(generateEphemeralKeypair());
@@ -3781,10 +3838,10 @@ function batchGenerateManagedEphemeralKeypairs(options) {
     throw new Error("count cannot exceed 1000 (security limit)");
   }
   const keypairs = [];
-  let entropyState = entropyMixing ? (0, import_utils21.randomBytes)(32) : null;
+  let entropyState = entropyMixing ? (0, import_utils22.randomBytes)(32) : null;
   for (let i = 0; i < count; i++) {
     if (entropyMixing && entropyState) {
-      const extraEntropy = (0, import_utils21.randomBytes)(32);
+      const extraEntropy = (0, import_utils22.randomBytes)(32);
       entropyState = (0, import_sha2566.sha256)(new Uint8Array([...entropyState, ...extraEntropy]));
     }
     keypairs.push(generateManagedEphemeralKeypair());
@@ -3800,15 +3857,15 @@ function disposeEphemeralKeypairs(keypairs) {
   }
 }
 function wipeEphemeralPrivateKey(privateKeyHex) {
-  const bytes = (0, import_utils21.hexToBytes)(privateKeyHex.slice(2));
+  const bytes = (0, import_utils22.hexToBytes)(privateKeyHex.slice(2));
   secureWipe(bytes);
 }
-var import_ed255195, import_utils21, import_sha2566;
+var import_ed255195, import_utils22, import_sha2566;
 var init_ephemeral_keys = __esm({
   "src/chains/solana/ephemeral-keys.ts"() {
     "use strict";
     import_ed255195 = require("@noble/curves/ed25519");
-    import_utils21 = require("@noble/hashes/utils");
+    import_utils22 = require("@noble/hashes/utils");
     import_sha2566 = require("@noble/hashes/sha256");
     init_secure_memory();
     init_stealth2();
@@ -4031,16 +4088,16 @@ var init_helius = __esm({
 // src/chains/solana/providers/generic.ts
 function validateSolanaAddress(address, paramName) {
   try {
-    return new import_web37.PublicKey(address);
+    return new import_web38.PublicKey(address);
   } catch {
     throw new ValidationError("invalid Solana address format", paramName, void 0, "SIP_2007" /* INVALID_ADDRESS */);
   }
 }
-var import_web37, import_spl_token4, CLUSTER_ENDPOINTS, GenericProvider;
+var import_web38, import_spl_token4, CLUSTER_ENDPOINTS, GenericProvider;
 var init_generic = __esm({
   "src/chains/solana/providers/generic.ts"() {
     "use strict";
-    import_web37 = require("@solana/web3.js");
+    import_web38 = require("@solana/web3.js");
     import_spl_token4 = require("@solana/spl-token");
     init_errors();
     init_constants();
@@ -4057,7 +4114,7 @@ var init_generic = __esm({
           this.connection = config.connection;
         } else {
           const endpoint = config.endpoint ?? CLUSTER_ENDPOINTS[config.cluster ?? "mainnet-beta"];
-          this.connection = new import_web37.Connection(endpoint, "confirmed");
+          this.connection = new import_web38.Connection(endpoint, "confirmed");
         }
       }
       /**
@@ -4153,7 +4210,7 @@ var init_generic = __esm({
 // src/chains/solana/providers/quicknode.ts
 function validateSolanaAddress2(address, paramName) {
   try {
-    return new import_web38.PublicKey(address);
+    return new import_web39.PublicKey(address);
   } catch {
     throw new ValidationError("invalid Solana address format", paramName, void 0, "SIP_2007" /* INVALID_ADDRESS */);
   }
@@ -4163,11 +4220,11 @@ function getGrpcEndpoint(rpcEndpoint) {
   url.port = "10000";
   return url.origin + url.pathname.replace(/\/$/, "");
 }
-var import_web38, import_spl_token5, import_yellowstone_grpc, import_base, QuickNodeProvider;
+var import_web39, import_spl_token5, import_yellowstone_grpc, import_base, QuickNodeProvider;
 var init_quicknode = __esm({
   "src/chains/solana/providers/quicknode.ts"() {
     "use strict";
-    import_web38 = require("@solana/web3.js");
+    import_web39 = require("@solana/web3.js");
     import_spl_token5 = require("@solana/spl-token");
     import_yellowstone_grpc = __toESM(require("@triton-one/yellowstone-grpc"));
     import_base = require("@scure/base");
@@ -4202,7 +4259,7 @@ var init_quicknode = __esm({
             "SIP_2001" /* INVALID_INPUT */
           );
         }
-        this.connection = new import_web38.Connection(config.endpoint, "confirmed");
+        this.connection = new import_web39.Connection(config.endpoint, "confirmed");
         this.grpcEndpoint = getGrpcEndpoint(config.endpoint);
         this.grpcEnabled = config.enableGrpc !== false;
       }
@@ -4278,7 +4335,7 @@ var init_quicknode = __esm({
           return cached;
         }
         try {
-          const mintPubkey = new import_web38.PublicKey(mint);
+          const mintPubkey = new import_web39.PublicKey(mint);
           const mintInfo = await (0, import_spl_token5.getMint)(this.connection, mintPubkey);
           const decimals = mintInfo.decimals;
           this.mintDecimalsCache.set(mint, decimals);
@@ -4326,7 +4383,7 @@ var init_quicknode = __esm({
               try {
                 const data = accountData.data;
                 if (data && data.length >= 72) {
-                  const mint = new import_web38.PublicKey(data.slice(0, 32)).toBase58();
+                  const mint = new import_web39.PublicKey(data.slice(0, 32)).toBase58();
                   const amount = BigInt(
                     "0x" + Buffer.from(data.slice(64, 72)).reverse().toString("hex")
                   );
@@ -4428,16 +4485,16 @@ var init_quicknode = __esm({
 // src/chains/solana/providers/triton.ts
 function validateSolanaAddress3(address, paramName) {
   try {
-    return new import_web39.PublicKey(address);
+    return new import_web310.PublicKey(address);
   } catch {
     throw new ValidationError("invalid Solana address format", paramName, void 0, "SIP_2007" /* INVALID_ADDRESS */);
   }
 }
-var import_web39, import_spl_token6, import_yellowstone_grpc2, import_base2, TRITON_RPC_ENDPOINTS, TRITON_GRPC_ENDPOINTS, TritonProvider;
+var import_web310, import_spl_token6, import_yellowstone_grpc2, import_base2, TRITON_RPC_ENDPOINTS, TRITON_GRPC_ENDPOINTS, TritonProvider;
 var init_triton = __esm({
   "src/chains/solana/providers/triton.ts"() {
     "use strict";
-    import_web39 = require("@solana/web3.js");
+    import_web310 = require("@solana/web3.js");
     import_spl_token6 = require("@solana/spl-token");
     import_yellowstone_grpc2 = __toESM(require("@triton-one/yellowstone-grpc"));
     import_base2 = require("@scure/base");
@@ -4474,7 +4531,7 @@ var init_triton = __esm({
         const rpcEndpoint = config.endpoint ?? TRITON_RPC_ENDPOINTS[cluster];
         const normalizedEndpoint = rpcEndpoint.replace(/\/$/, "");
         const rpcUrl = normalizedEndpoint.includes("?") ? `${normalizedEndpoint}&x-token=${config.xToken}` : `${normalizedEndpoint}/${config.xToken}`;
-        this.connection = new import_web39.Connection(rpcUrl, "confirmed");
+        this.connection = new import_web310.Connection(rpcUrl, "confirmed");
         this.grpcEndpoint = config.grpcEndpoint ?? TRITON_GRPC_ENDPOINTS[cluster];
         this.xToken = config.xToken;
         this.grpcEnabled = config.enableGrpc !== false;
@@ -4551,7 +4608,7 @@ var init_triton = __esm({
           return cached;
         }
         try {
-          const mintPubkey = new import_web39.PublicKey(mint);
+          const mintPubkey = new import_web310.PublicKey(mint);
           const mintInfo = await (0, import_spl_token6.getMint)(this.connection, mintPubkey);
           const decimals = mintInfo.decimals;
           this.mintDecimalsCache.set(mint, decimals);
@@ -4602,7 +4659,7 @@ var init_triton = __esm({
               try {
                 const data = accountData.data;
                 if (data && data.length >= 72) {
-                  const mint = new import_web39.PublicKey(data.slice(0, 32)).toBase58();
+                  const mint = new import_web310.PublicKey(data.slice(0, 32)).toBase58();
                   const amount = BigInt(
                     "0x" + Buffer.from(data.slice(64, 72)).reverse().toString("hex")
                   );
@@ -4759,7 +4816,7 @@ function verifyWebhookSignature(rawBody, signature, secret) {
   }
   try {
     const encoder = new TextEncoder();
-    const expectedSignature = (0, import_utils23.bytesToHex)(
+    const expectedSignature = (0, import_utils24.bytesToHex)(
       (0, import_hmac2.hmac)(import_sha2567.sha256, encoder.encode(secret), encoder.encode(rawBody))
     );
     if (signature.length !== expectedSignature.length) {
@@ -4938,6 +4995,7 @@ async function processRawTransaction(tx, viewingPrivateKey, spendingPublicKey, o
       const payment = {
         stealthAddress: announcement.stealthAddress || "",
         ephemeralPublicKey: announcement.ephemeralPublicKey,
+        version: announcement.version,
         amount: transferInfo?.amount ?? 0n,
         mint: transferInfo?.mint ?? "",
         tokenSymbol: transferInfo?.mint ? getTokenSymbol(transferInfo.mint) : void 0,
@@ -4977,7 +5035,7 @@ async function processWebhookTransaction(transaction, viewingPrivateKey, spendin
   );
   return result.found ? result.payment ?? null : null;
 }
-var import_hmac2, import_sha2567, import_utils23;
+var import_hmac2, import_sha2567, import_utils24;
 var init_webhook = __esm({
   "src/chains/solana/providers/webhook.ts"() {
     "use strict";
@@ -4988,7 +5046,7 @@ var init_webhook = __esm({
     init_errors();
     import_hmac2 = require("@noble/hashes/hmac");
     import_sha2567 = require("@noble/hashes/sha256");
-    import_utils23 = require("@noble/hashes/utils");
+    import_utils24 = require("@noble/hashes/utils");
   }
 });
 
@@ -5421,11 +5479,11 @@ var init_providers = __esm({
 function createSolanaPrivacyAdapter(config) {
   return new SolanaPrivacyAdapter(config);
 }
-var import_web310, SolanaPrivacyAdapter;
+var import_web311, SolanaPrivacyAdapter;
 var init_privacy_adapter = __esm({
   "src/chains/solana/privacy-adapter.ts"() {
     "use strict";
-    import_web310 = require("@solana/web3.js");
+    import_web311 = require("@solana/web3.js");
     init_stealth2();
     init_transfer();
     init_scan();
@@ -5655,7 +5713,8 @@ var init_privacy_adapter = __esm({
           viewingPrivateKey: params.viewingPrivateKey,
           spendingPrivateKey: params.spendingPrivateKey,
           destinationAddress: params.destinationAddress,
-          mint: new import_web310.PublicKey(params.payment.mint)
+          mint: new import_web311.PublicKey(params.payment.mint),
+          version: params.payment.version
         });
       }
       /**
@@ -5894,7 +5953,7 @@ function generateH2() {
       if (!point.equals(import_ed255197.ed25519.ExtendedPoint.ZERO)) {
         const gBytes = G2.toRawBytes();
         const hBytes = point.toRawBytes();
-        if ((0, import_utils25.bytesToHex)(gBytes) !== (0, import_utils25.bytesToHex)(hBytes)) {
+        if ((0, import_utils26.bytesToHex)(gBytes) !== (0, import_utils26.bytesToHex)(hBytes)) {
           return point;
         }
       }
@@ -5922,13 +5981,13 @@ function commitSolana(value, blinding) {
       { curveOrder: ED25519_ORDER2.toString(16) }
     );
   }
-  const r = blinding ?? (0, import_utils25.randomBytes)(32);
+  const r = blinding ?? (0, import_utils26.randomBytes)(32);
   if (r.length !== 32) {
     throw new ValidationError("must be 32 bytes", "blinding", { received: r.length });
   }
   const rScalar = bytesToBigInt3(r) % ED25519_ORDER2;
   if (rScalar === 0n) {
-    return commitSolana(value, (0, import_utils25.randomBytes)(32));
+    return commitSolana(value, (0, import_utils26.randomBytes)(32));
   }
   let C;
   if (value === 0n) {
@@ -5940,8 +5999,8 @@ function commitSolana(value, blinding) {
   }
   const rScalarBytes = bigIntToBytes3(rScalar, 32);
   return {
-    commitment: `0x${(0, import_utils25.bytesToHex)(C.toRawBytes())}`,
-    blinding: `0x${(0, import_utils25.bytesToHex)(rScalarBytes)}`
+    commitment: `0x${(0, import_utils26.bytesToHex)(C.toRawBytes())}`,
+    blinding: `0x${(0, import_utils26.bytesToHex)(rScalarBytes)}`
   };
 }
 function verifyOpeningSolana(commitment, value, blinding) {
@@ -6027,7 +6086,7 @@ function addCommitmentsSolana(c1, c2) {
   }
   const sum = point1.add(point2);
   return {
-    commitment: `0x${(0, import_utils25.bytesToHex)(sum.toRawBytes())}`
+    commitment: `0x${(0, import_utils26.bytesToHex)(sum.toRawBytes())}`
   };
 }
 function subtractCommitmentsSolana(c1, c2) {
@@ -6056,7 +6115,7 @@ function subtractCommitmentsSolana(c1, c2) {
     };
   }
   return {
-    commitment: `0x${(0, import_utils25.bytesToHex)(diff.toRawBytes())}`
+    commitment: `0x${(0, import_utils26.bytesToHex)(diff.toRawBytes())}`
   };
 }
 function addBlindingsSolana(b1, b2) {
@@ -6064,23 +6123,23 @@ function addBlindingsSolana(b1, b2) {
   const r2 = bytesToBigInt3(hexToBytes9(b2.slice(2)));
   const sum = (r1 + r2) % ED25519_ORDER2;
   const sumBytes = bigIntToBytes3(sum, 32);
-  return `0x${(0, import_utils25.bytesToHex)(sumBytes)}`;
+  return `0x${(0, import_utils26.bytesToHex)(sumBytes)}`;
 }
 function subtractBlindingsSolana(b1, b2) {
   const r1 = bytesToBigInt3(hexToBytes9(b1.slice(2)));
   const r2 = bytesToBigInt3(hexToBytes9(b2.slice(2)));
   const diff = (r1 - r2 + ED25519_ORDER2) % ED25519_ORDER2;
   const diffBytes = bigIntToBytes3(diff, 32);
-  return `0x${(0, import_utils25.bytesToHex)(diffBytes)}`;
+  return `0x${(0, import_utils26.bytesToHex)(diffBytes)}`;
 }
 function getGeneratorsSolana() {
   return {
-    G: `0x${(0, import_utils25.bytesToHex)(G2.toRawBytes())}`,
-    H: `0x${(0, import_utils25.bytesToHex)(H2.toRawBytes())}`
+    G: `0x${(0, import_utils26.bytesToHex)(G2.toRawBytes())}`,
+    H: `0x${(0, import_utils26.bytesToHex)(H2.toRawBytes())}`
   };
 }
 function generateBlindingSolana() {
-  return `0x${(0, import_utils25.bytesToHex)((0, import_utils25.randomBytes)(32))}`;
+  return `0x${(0, import_utils26.bytesToHex)((0, import_utils26.randomBytes)(32))}`;
 }
 function bytesToBigInt3(bytes) {
   let result = 0n;
@@ -6105,13 +6164,13 @@ function hexToBytes9(hex) {
   }
   return bytes;
 }
-var import_ed255197, import_sha22, import_utils25, H_DOMAIN2, G2, ED25519_ORDER2, ED25519_COFACTOR, MAX_SPL_AMOUNT, H2;
+var import_ed255197, import_sha22, import_utils26, H_DOMAIN2, G2, ED25519_ORDER2, ED25519_COFACTOR, MAX_SPL_AMOUNT, H2;
 var init_commitment2 = __esm({
   "src/chains/solana/commitment.ts"() {
     "use strict";
     import_ed255197 = require("@noble/curves/ed25519");
     import_sha22 = require("@noble/hashes/sha2");
-    import_utils25 = require("@noble/hashes/utils");
+    import_utils26 = require("@noble/hashes/utils");
     init_errors();
     init_validation();
     H_DOMAIN2 = "SIP-SOLANA-PEDERSEN-GENERATOR-H-v1";
@@ -6131,7 +6190,7 @@ function generateViewingKeyFromSpending(spendingPrivateKey, label) {
       "spendingPrivateKey"
     );
   }
-  const spendingBytes = (0, import_utils26.hexToBytes)(spendingPrivateKey.slice(2));
+  const spendingBytes = (0, import_utils27.hexToBytes)(spendingPrivateKey.slice(2));
   if (spendingBytes.length !== 32) {
     throw new ValidationError(
       "spendingPrivateKey must be 32 bytes",
@@ -6142,15 +6201,15 @@ function generateViewingKeyFromSpending(spendingPrivateKey, label) {
   try {
     viewingPrivateBytes = (0, import_hmac4.hmac)(
       import_sha2568.sha256,
-      (0, import_utils26.utf8ToBytes)(VIEWING_KEY_CONTEXT2),
+      (0, import_utils27.utf8ToBytes)(VIEWING_KEY_CONTEXT2),
       spendingBytes
     );
     const viewingPublicBytes = import_ed255198.ed25519.getPublicKey(viewingPrivateBytes);
     const hashBytes = (0, import_sha2568.sha256)(viewingPublicBytes);
     return {
-      privateKey: `0x${(0, import_utils26.bytesToHex)(viewingPrivateBytes)}`,
-      publicKey: `0x${(0, import_utils26.bytesToHex)(viewingPublicBytes)}`,
-      hash: `0x${(0, import_utils26.bytesToHex)(hashBytes)}`,
+      privateKey: `0x${(0, import_utils27.bytesToHex)(viewingPrivateBytes)}`,
+      publicKey: `0x${(0, import_utils27.bytesToHex)(viewingPublicBytes)}`,
+      hash: `0x${(0, import_utils27.bytesToHex)(hashBytes)}`,
       label,
       createdAt: Date.now()
     };
@@ -6160,14 +6219,14 @@ function generateViewingKeyFromSpending(spendingPrivateKey, label) {
   }
 }
 function generateRandomViewingKey(label) {
-  const privateBytes = (0, import_utils26.randomBytes)(32);
+  const privateBytes = (0, import_utils27.randomBytes)(32);
   try {
     const publicBytes = import_ed255198.ed25519.getPublicKey(privateBytes);
     const hashBytes = (0, import_sha2568.sha256)(publicBytes);
     return {
-      privateKey: `0x${(0, import_utils26.bytesToHex)(privateBytes)}`,
-      publicKey: `0x${(0, import_utils26.bytesToHex)(publicBytes)}`,
-      hash: `0x${(0, import_utils26.bytesToHex)(hashBytes)}`,
+      privateKey: `0x${(0, import_utils27.bytesToHex)(privateBytes)}`,
+      publicKey: `0x${(0, import_utils27.bytesToHex)(publicBytes)}`,
+      hash: `0x${(0, import_utils27.bytesToHex)(hashBytes)}`,
       label,
       createdAt: Date.now()
     };
@@ -6182,7 +6241,7 @@ function computeViewingKeyHash(viewingPublicKey) {
       "viewingPublicKey"
     );
   }
-  const publicBytes = (0, import_utils26.hexToBytes)(viewingPublicKey.slice(2));
+  const publicBytes = (0, import_utils27.hexToBytes)(viewingPublicKey.slice(2));
   if (publicBytes.length !== 32) {
     throw new ValidationError(
       "viewingPublicKey must be 32 bytes",
@@ -6190,7 +6249,7 @@ function computeViewingKeyHash(viewingPublicKey) {
     );
   }
   const hashBytes = (0, import_sha2568.sha256)(publicBytes);
-  return `0x${(0, import_utils26.bytesToHex)(hashBytes)}`;
+  return `0x${(0, import_utils27.bytesToHex)(hashBytes)}`;
 }
 function computeViewingKeyHashFromPrivate(viewingPrivateKey) {
   if (!viewingPrivateKey || !viewingPrivateKey.startsWith("0x")) {
@@ -6199,7 +6258,7 @@ function computeViewingKeyHashFromPrivate(viewingPrivateKey) {
       "viewingPrivateKey"
     );
   }
-  const privateBytes = (0, import_utils26.hexToBytes)(viewingPrivateKey.slice(2));
+  const privateBytes = (0, import_utils27.hexToBytes)(viewingPrivateKey.slice(2));
   if (privateBytes.length !== 32) {
     throw new ValidationError(
       "viewingPrivateKey must be 32 bytes",
@@ -6209,7 +6268,7 @@ function computeViewingKeyHashFromPrivate(viewingPrivateKey) {
   try {
     const publicBytes = import_ed255198.ed25519.getPublicKey(privateBytes);
     const hashBytes = (0, import_sha2568.sha256)(publicBytes);
-    return `0x${(0, import_utils26.bytesToHex)(hashBytes)}`;
+    return `0x${(0, import_utils27.bytesToHex)(hashBytes)}`;
   } finally {
     secureWipe(privateBytes);
   }
@@ -6256,9 +6315,9 @@ function importViewingKey(exported) {
       { expected: computedHash, received: exported.hash }
     );
   }
-  const privateBytes = (0, import_utils26.hexToBytes)(exported.privateKey.slice(2));
+  const privateBytes = (0, import_utils27.hexToBytes)(exported.privateKey.slice(2));
   try {
-    const derivedPublic = `0x${(0, import_utils26.bytesToHex)(import_ed255198.ed25519.getPublicKey(privateBytes))}`;
+    const derivedPublic = `0x${(0, import_utils27.bytesToHex)(import_ed255198.ed25519.getPublicKey(privateBytes))}`;
     if (derivedPublic !== exported.publicKey) {
       throw new ValidationError(
         "Public key does not match private key",
@@ -6277,10 +6336,10 @@ function importViewingKey(exported) {
   };
 }
 function deriveEncryptionKey2(key, salt) {
-  const keyBytes = (0, import_utils26.hexToBytes)(key.slice(2));
+  const keyBytes = (0, import_utils27.hexToBytes)(key.slice(2));
   try {
-    const hkdfSalt = salt ?? (0, import_utils26.utf8ToBytes)(ENCRYPTION_DOMAIN2);
-    return (0, import_hkdf2.hkdf)(import_sha2568.sha256, keyBytes, hkdfSalt, (0, import_utils26.utf8ToBytes)("encryption"), 32);
+    const hkdfSalt = salt ?? (0, import_utils27.utf8ToBytes)(ENCRYPTION_DOMAIN2);
+    return (0, import_hkdf2.hkdf)(import_sha2568.sha256, keyBytes, hkdfSalt, (0, import_utils27.utf8ToBytes)("encryption"), 32);
   } finally {
     secureWipe(keyBytes);
   }
@@ -6288,13 +6347,13 @@ function deriveEncryptionKey2(key, salt) {
 function encryptForViewing2(data, viewingKey) {
   const encKey = deriveEncryptionKey2(viewingKey.privateKey);
   try {
-    const nonce = (0, import_utils26.randomBytes)(NONCE_SIZE2);
-    const plaintext = (0, import_utils26.utf8ToBytes)(JSON.stringify(data));
+    const nonce = (0, import_utils27.randomBytes)(NONCE_SIZE2);
+    const plaintext = (0, import_utils27.utf8ToBytes)(JSON.stringify(data));
     const cipher = (0, import_chacha2.xchacha20poly1305)(encKey, nonce);
     const ciphertext = cipher.encrypt(plaintext);
     return {
-      ciphertext: `0x${(0, import_utils26.bytesToHex)(ciphertext)}`,
-      nonce: `0x${(0, import_utils26.bytesToHex)(nonce)}`,
+      ciphertext: `0x${(0, import_utils27.bytesToHex)(ciphertext)}`,
+      nonce: `0x${(0, import_utils27.bytesToHex)(nonce)}`,
       viewingKeyHash: viewingKey.hash
     };
   } finally {
@@ -6311,8 +6370,8 @@ function decryptWithViewing2(encrypted, viewingKey) {
   }
   const encKey = deriveEncryptionKey2(viewingKey.privateKey);
   try {
-    const ciphertext = (0, import_utils26.hexToBytes)(encrypted.ciphertext.slice(2));
-    const nonce = (0, import_utils26.hexToBytes)(encrypted.nonce.slice(2));
+    const ciphertext = (0, import_utils27.hexToBytes)(encrypted.ciphertext.slice(2));
+    const nonce = (0, import_utils27.hexToBytes)(encrypted.nonce.slice(2));
     if (nonce.length !== NONCE_SIZE2) {
       throw new ValidationError(
         `Invalid nonce length: ${nonce.length}. Expected: ${NONCE_SIZE2}`,
@@ -6362,15 +6421,15 @@ function deriveChildViewingKey(parentKey, childPath, label) {
   if (!childPath || typeof childPath !== "string") {
     throw new ValidationError("childPath must be a non-empty string", "childPath");
   }
-  const parentBytes = (0, import_utils26.hexToBytes)(parentKey.privateKey.slice(2));
+  const parentBytes = (0, import_utils27.hexToBytes)(parentKey.privateKey.slice(2));
   try {
-    const childBytes = (0, import_hmac4.hmac)(import_sha2568.sha256, (0, import_utils26.utf8ToBytes)(childPath), parentBytes);
+    const childBytes = (0, import_hmac4.hmac)(import_sha2568.sha256, (0, import_utils27.utf8ToBytes)(childPath), parentBytes);
     const publicBytes = import_ed255198.ed25519.getPublicKey(childBytes);
     const hashBytes = (0, import_sha2568.sha256)(publicBytes);
     const result = {
-      privateKey: `0x${(0, import_utils26.bytesToHex)(childBytes)}`,
-      publicKey: `0x${(0, import_utils26.bytesToHex)(publicBytes)}`,
-      hash: `0x${(0, import_utils26.bytesToHex)(hashBytes)}`,
+      privateKey: `0x${(0, import_utils27.bytesToHex)(childBytes)}`,
+      publicKey: `0x${(0, import_utils27.bytesToHex)(publicBytes)}`,
+      hash: `0x${(0, import_utils27.bytesToHex)(hashBytes)}`,
       label: label ?? `${parentKey.label ?? "Key"}/${childPath}`,
       createdAt: Date.now()
     };
@@ -6387,7 +6446,7 @@ function getViewingPublicKey(viewingPrivateKey) {
       "viewingPrivateKey"
     );
   }
-  const privateBytes = (0, import_utils26.hexToBytes)(viewingPrivateKey.slice(2));
+  const privateBytes = (0, import_utils27.hexToBytes)(viewingPrivateKey.slice(2));
   if (privateBytes.length !== 32) {
     throw new ValidationError(
       "viewingPrivateKey must be 32 bytes",
@@ -6396,12 +6455,12 @@ function getViewingPublicKey(viewingPrivateKey) {
   }
   try {
     const publicBytes = import_ed255198.ed25519.getPublicKey(privateBytes);
-    return `0x${(0, import_utils26.bytesToHex)(publicBytes)}`;
+    return `0x${(0, import_utils27.bytesToHex)(publicBytes)}`;
   } finally {
     secureWipe(privateBytes);
   }
 }
-var import_ed255198, import_sha2568, import_hmac4, import_hkdf2, import_utils26, import_chacha2, VIEWING_KEY_CONTEXT2, ENCRYPTION_DOMAIN2, NONCE_SIZE2, EXPORT_VERSION;
+var import_ed255198, import_sha2568, import_hmac4, import_hkdf2, import_utils27, import_chacha2, VIEWING_KEY_CONTEXT2, ENCRYPTION_DOMAIN2, NONCE_SIZE2, EXPORT_VERSION;
 var init_viewing_key = __esm({
   "src/chains/solana/viewing-key.ts"() {
     "use strict";
@@ -6409,7 +6468,7 @@ var init_viewing_key = __esm({
     import_sha2568 = require("@noble/hashes/sha256");
     import_hmac4 = require("@noble/hashes/hmac");
     import_hkdf2 = require("@noble/hashes/hkdf");
-    import_utils26 = require("@noble/hashes/utils");
+    import_utils27 = require("@noble/hashes/utils");
     import_chacha2 = require("@noble/ciphers/chacha.js");
     init_errors();
     init_validation();
@@ -6429,7 +6488,7 @@ function toAddress(pubkey) {
   return (0, import_compat.fromLegacyPublicKey)(pubkey);
 }
 function toPublicKey(addr) {
-  return new import_web311.PublicKey(addr);
+  return new import_web312.PublicKey(addr);
 }
 function createAddress(base583) {
   return (0, import_kit.address)(base583);
@@ -6447,7 +6506,7 @@ function createDualRpcClient(endpoint, wsEndpoint, commitment = "confirmed") {
   const derivedWsEndpoint = wsEndpoint ?? deriveWsEndpoint(endpoint);
   const rpc = (0, import_kit.createSolanaRpc)(endpoint);
   const rpcSubscriptions = (0, import_kit.createSolanaRpcSubscriptions)(derivedWsEndpoint);
-  const legacyConnection = new import_web311.Connection(endpoint, {
+  const legacyConnection = new import_web312.Connection(endpoint, {
     commitment,
     wsEndpoint: derivedWsEndpoint
   });
@@ -6486,28 +6545,28 @@ function isAddress(value) {
   return typeof value === "string" && value.length >= 32 && value.length <= 44;
 }
 function isPublicKey(value) {
-  return value instanceof import_web311.PublicKey;
+  return value instanceof import_web312.PublicKey;
 }
 function normalizeAddress(input) {
   let base583;
-  if (input instanceof import_web311.PublicKey) {
+  if (input instanceof import_web312.PublicKey) {
     base583 = input.toBase58();
   } else {
     base583 = input;
   }
   return {
     address: (0, import_kit.address)(base583),
-    publicKey: new import_web311.PublicKey(base583),
+    publicKey: new import_web312.PublicKey(base583),
     base58: base583
   };
 }
-var import_kit, import_compat, import_web311, LAMPORTS_PER_SOL2, RpcHelpers;
+var import_kit, import_compat, import_web312, LAMPORTS_PER_SOL2, RpcHelpers;
 var init_kit_compat = __esm({
   "src/chains/solana/kit-compat.ts"() {
     "use strict";
     import_kit = require("@solana/kit");
     import_compat = require("@solana/compat");
-    import_web311 = require("@solana/web3.js");
+    import_web312 = require("@solana/web3.js");
     LAMPORTS_PER_SOL2 = 1000000000n;
     RpcHelpers = {
       /**
@@ -10787,7 +10846,7 @@ var require_dist = __commonJS({
     var http = __importStar(require("http"));
     var https_1 = require("https");
     __exportStar(require_helpers3(), exports2);
-    var INTERNAL = Symbol("AgentBaseInternalState");
+    var INTERNAL = /* @__PURE__ */ Symbol("AgentBaseInternalState");
     var Agent = class extends http.Agent {
       constructor(opts) {
         super(opts);
@@ -12395,12 +12454,12 @@ function createClusterClient(cluster, options = {}) {
     ...options
   });
 }
-var import_kit2, import_web312, RPCErrorType, SolanaRPCClient, RPC_ENDPOINTS;
+var import_kit2, import_web313, RPCErrorType, SolanaRPCClient, RPC_ENDPOINTS;
 var init_rpc_client = __esm({
   "src/chains/solana/rpc-client.ts"() {
     "use strict";
     import_kit2 = require("@solana/kit");
-    import_web312 = require("@solana/web3.js");
+    import_web313 = require("@solana/web3.js");
     init_kit_compat();
     init_proxy();
     RPCErrorType = /* @__PURE__ */ ((RPCErrorType2) => {
@@ -12513,7 +12572,7 @@ var init_rpc_client = __esm({
         return {
           rpc: (0, import_kit2.createSolanaRpc)(endpoint),
           rpcSubscriptions: (0, import_kit2.createSolanaRpcSubscriptions)(wsEndpoint),
-          legacyConnection: new import_web312.Connection(endpoint, connectionOptions),
+          legacyConnection: new import_web313.Connection(endpoint, connectionOptions),
           endpoint
         };
       }
@@ -12585,7 +12644,7 @@ var init_rpc_client = __esm({
           ...sendOptions
         } = options;
         let txToSend = transaction;
-        if (this.usePriorityFees && !skipPriorityFee && transaction instanceof import_web312.Transaction) {
+        if (this.usePriorityFees && !skipPriorityFee && transaction instanceof import_web313.Transaction) {
           txToSend = await this.addPriorityFee(
             transaction,
             priorityFeeMicroLamports,
@@ -12728,14 +12787,14 @@ var init_rpc_client = __esm({
           const estimate = await this.estimatePriorityFee(transaction);
           feeToUse = estimate.microLamportsPerComputeUnit;
         }
-        const modifiedTx = new import_web312.Transaction();
+        const modifiedTx = new import_web313.Transaction();
         modifiedTx.add(
-          import_web312.ComputeBudgetProgram.setComputeUnitLimit({
+          import_web313.ComputeBudgetProgram.setComputeUnitLimit({
             units: computeUnitLimit ?? 2e5
           })
         );
         modifiedTx.add(
-          import_web312.ComputeBudgetProgram.setComputeUnitPrice({
+          import_web313.ComputeBudgetProgram.setComputeUnitPrice({
             microLamports: feeToUse
           })
         );
@@ -13025,9 +13084,9 @@ function estimateComputeUnits(instructions) {
       units += 3e4;
     } else if (programId === MEMO_PROGRAM_ID) {
       units += 2e3;
-    } else if (programId === import_web313.SystemProgram.programId.toBase58()) {
+    } else if (programId === import_web314.SystemProgram.programId.toBase58()) {
       units += 3e3;
-    } else if (programId === import_web313.ComputeBudgetProgram.programId.toBase58()) {
+    } else if (programId === import_web314.ComputeBudgetProgram.programId.toBase58()) {
       units += 500;
     }
   }
@@ -13047,11 +13106,11 @@ function calculatePriorityFee(priority) {
       return 1e3;
   }
 }
-var import_web313, import_spl_token7, DEFAULT_COMPUTE_UNITS, DEFAULT_PRIORITY_FEE, MIN_COMPUTE_UNITS, MAX_COMPUTE_UNITS, ShieldedTransactionType, ShieldedTransactionBuilder;
+var import_web314, import_spl_token7, DEFAULT_COMPUTE_UNITS, DEFAULT_PRIORITY_FEE, MIN_COMPUTE_UNITS, MAX_COMPUTE_UNITS, ShieldedTransactionType, ShieldedTransactionBuilder;
 var init_transaction_builder = __esm({
   "src/chains/solana/transaction-builder.ts"() {
     "use strict";
-    import_web313 = require("@solana/web3.js");
+    import_web314 = require("@solana/web3.js");
     import_spl_token7 = require("@solana/spl-token");
     init_stealth2();
     init_types();
@@ -13106,14 +13165,14 @@ var init_transaction_builder = __esm({
         }
         const { stealthAddress } = generateEd25519StealthAddress(recipientMetaAddress);
         const stealthAddressBase58 = ed25519PublicKeyToSolanaAddress(stealthAddress.address);
-        const stealthPubkey = new import_web313.PublicKey(stealthAddressBase58);
+        const stealthPubkey = new import_web314.PublicKey(stealthAddressBase58);
         const ephemeralPubkeyBase58 = ed25519PublicKeyToSolanaAddress(stealthAddress.ephemeralPublicKey);
         const stealthATA = await (0, import_spl_token7.getAssociatedTokenAddress)(mint, stealthPubkey, true);
         const instructions = [];
         if (this.priorityFee > 0) {
           instructions.push(
-            import_web313.ComputeBudgetProgram.setComputeUnitLimit({ units: this.computeUnits }),
-            import_web313.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.priorityFee })
+            import_web314.ComputeBudgetProgram.setComputeUnitLimit({ units: this.computeUnits }),
+            import_web314.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.priorityFee })
           );
         }
         let needsAtaCreation = false;
@@ -13145,9 +13204,9 @@ var init_transaction_builder = __esm({
           stealthAddressBase58
         );
         instructions.push(
-          new import_web313.TransactionInstruction({
+          new import_web314.TransactionInstruction({
             keys: [],
-            programId: new import_web313.PublicKey(MEMO_PROGRAM_ID),
+            programId: new import_web314.PublicKey(MEMO_PROGRAM_ID),
             data: Buffer.from(memoContent, "utf-8")
           })
         );
@@ -13179,17 +13238,17 @@ var init_transaction_builder = __esm({
         }
         const { stealthAddress } = generateEd25519StealthAddress(recipientMetaAddress);
         const stealthAddressBase58 = ed25519PublicKeyToSolanaAddress(stealthAddress.address);
-        const stealthPubkey = new import_web313.PublicKey(stealthAddressBase58);
+        const stealthPubkey = new import_web314.PublicKey(stealthAddressBase58);
         const ephemeralPubkeyBase58 = ed25519PublicKeyToSolanaAddress(stealthAddress.ephemeralPublicKey);
         const instructions = [];
         if (this.priorityFee > 0) {
           instructions.push(
-            import_web313.ComputeBudgetProgram.setComputeUnitLimit({ units: this.computeUnits }),
-            import_web313.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.priorityFee })
+            import_web314.ComputeBudgetProgram.setComputeUnitLimit({ units: this.computeUnits }),
+            import_web314.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.priorityFee })
           );
         }
         instructions.push(
-          import_web313.SystemProgram.transfer({
+          import_web314.SystemProgram.transfer({
             fromPubkey: sender,
             toPubkey: stealthPubkey,
             lamports: amount
@@ -13202,9 +13261,9 @@ var init_transaction_builder = __esm({
           stealthAddressBase58
         );
         instructions.push(
-          new import_web313.TransactionInstruction({
+          new import_web314.TransactionInstruction({
             keys: [],
-            programId: new import_web313.PublicKey(MEMO_PROGRAM_ID),
+            programId: new import_web314.PublicKey(MEMO_PROGRAM_ID),
             data: Buffer.from(memoContent, "utf-8")
           })
         );
@@ -13237,8 +13296,8 @@ var init_transaction_builder = __esm({
         );
         if (this.priorityFee > 0) {
           instructions.push(
-            import_web313.ComputeBudgetProgram.setComputeUnitLimit({ units: batchComputeUnits }),
-            import_web313.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.priorityFee })
+            import_web314.ComputeBudgetProgram.setComputeUnitLimit({ units: batchComputeUnits }),
+            import_web314.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: this.priorityFee })
           );
         }
         for (const transfer of transfers) {
@@ -13247,7 +13306,7 @@ var init_transaction_builder = __esm({
           }
           const { stealthAddress } = generateEd25519StealthAddress(transfer.recipientMetaAddress);
           const stealthAddressBase58 = ed25519PublicKeyToSolanaAddress(stealthAddress.address);
-          const stealthPubkey = new import_web313.PublicKey(stealthAddressBase58);
+          const stealthPubkey = new import_web314.PublicKey(stealthAddressBase58);
           const ephemeralPubkeyBase58 = ed25519PublicKeyToSolanaAddress(stealthAddress.ephemeralPublicKey);
           const stealthATA = await (0, import_spl_token7.getAssociatedTokenAddress)(mint, stealthPubkey, true);
           try {
@@ -13286,9 +13345,9 @@ var init_transaction_builder = __esm({
             stealthAddressBase58
           );
           instructions.push(
-            new import_web313.TransactionInstruction({
+            new import_web314.TransactionInstruction({
               keys: [],
-              programId: new import_web313.PublicKey(MEMO_PROGRAM_ID),
+              programId: new import_web314.PublicKey(MEMO_PROGRAM_ID),
               data: Buffer.from(memoContent, "utf-8")
             })
           );
@@ -13320,12 +13379,12 @@ var init_transaction_builder = __esm({
         const priorityFee = BigInt(Math.ceil(effectiveComputeUnits * this.priorityFee / 1e6));
         const estimatedFee = baseFee + priorityFee;
         if (this.useVersioned) {
-          const messageV0 = new import_web313.TransactionMessage({
+          const messageV0 = new import_web314.TransactionMessage({
             payerKey: this.feePayer,
             recentBlockhash: blockhash,
             instructions
           }).compileToV0Message(this.lookupTables.length > 0 ? this.lookupTables : void 0);
-          const versionedTransaction = new import_web313.VersionedTransaction(messageV0);
+          const versionedTransaction = new import_web314.VersionedTransaction(messageV0);
           return {
             type,
             versionedTransaction,
@@ -13336,7 +13395,7 @@ var init_transaction_builder = __esm({
             estimatedFee
           };
         } else {
-          const transaction = new import_web313.Transaction();
+          const transaction = new import_web314.Transaction();
           transaction.recentBlockhash = blockhash;
           transaction.lastValidBlockHeight = lastValidBlockHeight;
           transaction.feePayer = this.feePayer;
@@ -13381,9 +13440,9 @@ var init_transaction_builder = __esm({
       deserializeSignedTransaction(serialized, isVersioned) {
         const buffer = Buffer.from(serialized, "base64");
         if (isVersioned) {
-          return import_web313.VersionedTransaction.deserialize(buffer);
+          return import_web314.VersionedTransaction.deserialize(buffer);
         } else {
-          return import_web313.Transaction.from(buffer);
+          return import_web314.Transaction.from(buffer);
         }
       }
       // ─── Configuration ────────────────────────────────────────────────────────────
@@ -13455,9 +13514,9 @@ async function shieldedTransfer(params) {
   const stealthResult = generateEd25519StealthAddress(recipientMeta);
   const stealthAddr = stealthResult.stealthAddress;
   const stealthPubkey = ed25519PublicKeyToSolanaAddress(stealthAddr.address);
-  const stealthAccountPubkey = new import_web314.PublicKey(stealthPubkey);
+  const stealthAccountPubkey = new import_web315.PublicKey(stealthPubkey);
   const { commitment, blinding } = commit(amount);
-  const commitmentBytes = (0, import_utils27.hexToBytes)(commitment.slice(2));
+  const commitmentBytes = (0, import_utils28.hexToBytes)(commitment.slice(2));
   if (commitmentBytes.length !== 33) {
     throw new ValidationError(
       `Invalid commitment size: ${commitmentBytes.length}, expected 33`,
@@ -13465,21 +13524,21 @@ async function shieldedTransfer(params) {
     );
   }
   const ephemeralPubkeyHex = stealthAddr.ephemeralPublicKey;
-  const ephemeralPubkeyBytes = (0, import_utils27.hexToBytes)(ephemeralPubkeyHex.slice(2));
+  const ephemeralPubkeyBytes = (0, import_utils28.hexToBytes)(ephemeralPubkeyHex.slice(2));
   const ephemeralPubkey33 = new Uint8Array(33);
   ephemeralPubkey33[0] = 2;
   ephemeralPubkey33.set(ephemeralPubkeyBytes.slice(0, 32), 1);
-  const viewingKeyBytes = (0, import_utils27.hexToBytes)(recipientMeta.viewingKey.slice(2));
+  const viewingKeyBytes = (0, import_utils28.hexToBytes)(recipientMeta.viewingKey.slice(2));
   const viewingKeyHash = (0, import_sha23.sha256)(viewingKeyBytes);
   const encryptedAmount = encryptAmount(amount, recipientMeta.viewingKey);
-  const encryptedAmountBytes = (0, import_utils27.hexToBytes)(encryptedAmount.slice(2));
+  const encryptedAmountBytes = (0, import_utils28.hexToBytes)(encryptedAmount.slice(2));
   const mockProof = createMockProof(commitment, amount, blinding);
   const configAccount = await connection.getAccountInfo(CONFIG_PDA);
   if (!configAccount) {
     throw new ValidationError("SIP Privacy program not initialized", "config");
   }
   const totalTransfers = configAccount.data.readBigUInt64LE(43);
-  const [transferRecordPda] = import_web314.PublicKey.findProgramAddressSync(
+  const [transferRecordPda] = import_web315.PublicKey.findProgramAddressSync(
     [
       TRANSFER_RECORD_SEED,
       sender.toBuffer(),
@@ -13496,19 +13555,19 @@ async function shieldedTransfer(params) {
     proof: mockProof,
     actualAmount: amount
   });
-  const instruction = new import_web314.TransactionInstruction({
+  const instruction = new import_web315.TransactionInstruction({
     keys: [
       { pubkey: CONFIG_PDA, isSigner: false, isWritable: true },
       { pubkey: transferRecordPda, isSigner: false, isWritable: true },
       { pubkey: sender, isSigner: true, isWritable: true },
       { pubkey: stealthAccountPubkey, isSigner: false, isWritable: true },
       { pubkey: FEE_COLLECTOR, isSigner: false, isWritable: true },
-      { pubkey: import_web314.SystemProgram.programId, isSigner: false, isWritable: false }
+      { pubkey: import_web315.SystemProgram.programId, isSigner: false, isWritable: false }
     ],
     programId: SIP_PRIVACY_PROGRAM_ID,
     data: instructionData
   });
-  const transaction = new import_web314.Transaction();
+  const transaction = new import_web315.Transaction();
   transaction.add(instruction);
   const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
   transaction.recentBlockhash = blockhash;
@@ -13528,7 +13587,7 @@ async function shieldedTransfer(params) {
     ephemeralPublicKey: ephemeralPubkeyHex,
     commitment,
     viewTag: `0x${stealthAddr.viewTag.toString(16).padStart(2, "0")}`,
-    viewingKeyHash: `0x${(0, import_utils27.bytesToHex)(viewingKeyHash)}`,
+    viewingKeyHash: `0x${(0, import_utils28.bytesToHex)(viewingKeyHash)}`,
     explorerUrl: `https://solscan.io/tx/${signature}?cluster=${cluster}`
   };
 }
@@ -13575,12 +13634,12 @@ function buildShieldedTransferData(params) {
 }
 function createMockProof(commitment, amount, blinding) {
   const proof = new Uint8Array(128);
-  const commitmentBytes = (0, import_utils27.hexToBytes)(commitment.slice(2));
+  const commitmentBytes = (0, import_utils28.hexToBytes)(commitment.slice(2));
   const inputHash = (0, import_sha23.sha256)(
     new Uint8Array([
       ...commitmentBytes,
       ...bigintToLeBytes(amount),
-      ...(0, import_utils27.hexToBytes)(blinding.slice(2))
+      ...(0, import_utils28.hexToBytes)(blinding.slice(2))
     ])
   );
   proof.set(inputHash, 0);
@@ -13604,30 +13663,30 @@ async function getCluster(connection) {
 }
 function encryptAmount(amount, viewingKey) {
   const amountBytes = bigintToLeBytes(amount);
-  const keyHash = (0, import_sha23.sha256)((0, import_utils27.hexToBytes)(viewingKey.slice(2)));
+  const keyHash = (0, import_sha23.sha256)((0, import_utils28.hexToBytes)(viewingKey.slice(2)));
   const encrypted = new Uint8Array(amountBytes.length);
   for (let i = 0; i < amountBytes.length; i++) {
     encrypted[i] = amountBytes[i] ^ keyHash[i];
   }
-  return `0x${(0, import_utils27.bytesToHex)(encrypted)}`;
+  return `0x${(0, import_utils28.bytesToHex)(encrypted)}`;
 }
-var import_web314, import_sha23, import_utils27, SIP_PRIVACY_PROGRAM_ID, CONFIG_PDA, FEE_COLLECTOR, TRANSFER_RECORD_SEED, SHIELDED_TRANSFER_DISCRIMINATOR;
+var import_web315, import_sha23, import_utils28, SIP_PRIVACY_PROGRAM_ID, CONFIG_PDA, FEE_COLLECTOR, TRANSFER_RECORD_SEED, SHIELDED_TRANSFER_DISCRIMINATOR;
 var init_anchor_transfer = __esm({
   "src/chains/solana/anchor-transfer.ts"() {
     "use strict";
-    import_web314 = require("@solana/web3.js");
+    import_web315 = require("@solana/web3.js");
     import_sha23 = require("@noble/hashes/sha2");
-    import_utils27 = require("@noble/hashes/utils");
+    import_utils28 = require("@noble/hashes/utils");
     init_errors();
     init_commitment();
     init_stealth2();
-    SIP_PRIVACY_PROGRAM_ID = new import_web314.PublicKey(
+    SIP_PRIVACY_PROGRAM_ID = new import_web315.PublicKey(
       "S1PMFspo4W6BYKHWkHNF7kZ3fnqibEXg3LQjxepS9at"
     );
-    CONFIG_PDA = new import_web314.PublicKey(
+    CONFIG_PDA = new import_web315.PublicKey(
       "BVawZkppFewygA5nxdrLma4ThKx8Th7bW4KTCkcWTZwZ"
     );
-    FEE_COLLECTOR = new import_web314.PublicKey(
+    FEE_COLLECTOR = new import_web315.PublicKey(
       "S1P6j1yeTm6zkewQVeihrTZvmfoHABRkHDhabWTuWMd"
     );
     TRANSFER_RECORD_SEED = Buffer.from("transfer_record");
@@ -13650,24 +13709,24 @@ function createVerifyInstructionData(proof, publicInputs) {
 }
 function formatFundingInputs(params) {
   return [
-    (0, import_utils28.hexToBytes)(params.commitmentHash.slice(2)),
+    (0, import_utils29.hexToBytes)(params.commitmentHash.slice(2)),
     bigintToBytes32(params.minimumRequired),
-    (0, import_utils28.hexToBytes)(params.assetId.slice(2))
+    (0, import_utils29.hexToBytes)(params.assetId.slice(2))
   ];
 }
 function formatOwnershipInputs(params) {
   return [
-    (0, import_utils28.hexToBytes)(params.stealthPubkey.slice(2)),
-    (0, import_utils28.hexToBytes)(params.ephemeralPubkey.slice(2)),
-    (0, import_utils28.hexToBytes)(params.nullifier.slice(2))
+    (0, import_utils29.hexToBytes)(params.stealthPubkey.slice(2)),
+    (0, import_utils29.hexToBytes)(params.ephemeralPubkey.slice(2)),
+    (0, import_utils29.hexToBytes)(params.nullifier.slice(2))
   ];
 }
 function toPublicKey2(input) {
-  return typeof input === "string" ? new import_web315.PublicKey(input) : input;
+  return typeof input === "string" ? new import_web316.PublicKey(input) : input;
 }
 function toBytes(input) {
   if (typeof input === "string") {
-    return (0, import_utils28.hexToBytes)(input.startsWith("0x") ? input.slice(2) : input);
+    return (0, import_utils29.hexToBytes)(input.startsWith("0x") ? input.slice(2) : input);
   }
   return input;
 }
@@ -13680,13 +13739,13 @@ function bigintToBytes32(value) {
   }
   return bytes;
 }
-var import_web315, import_utils28, ProofType, DEFAULT_COMPUTE_UNITS2, PROOF_SIZE, SunspotVerifier;
+var import_web316, import_utils29, ProofType, DEFAULT_COMPUTE_UNITS2, PROOF_SIZE, SunspotVerifier;
 var init_sunspot_verifier = __esm({
   "src/chains/solana/sunspot-verifier.ts"() {
     "use strict";
-    import_web315 = require("@solana/web3.js");
+    import_web316 = require("@solana/web3.js");
     init_errors();
-    import_utils28 = require("@noble/hashes/utils");
+    import_utils29 = require("@noble/hashes/utils");
     ProofType = /* @__PURE__ */ ((ProofType2) => {
       ProofType2["Funding"] = "funding";
       ProofType2["Ownership"] = "ownership";
@@ -13801,14 +13860,14 @@ var init_sunspot_verifier = __esm({
           proofBytes,
           ...publicInputBytes.map((b) => Buffer.from(b))
         ]);
-        const transaction = new import_web315.Transaction();
+        const transaction = new import_web316.Transaction();
         transaction.add(
-          import_web315.ComputeBudgetProgram.setComputeUnitLimit({
+          import_web316.ComputeBudgetProgram.setComputeUnitLimit({
             units: this.config.computeUnits
           })
         );
         transaction.add(
-          new import_web315.TransactionInstruction({
+          new import_web316.TransactionInstruction({
             keys: [],
             // Verifier programs typically don't need accounts
             programId: verifierProgram,
@@ -13906,6 +13965,202 @@ var init_sunspot_verifier = __esm({
   }
 });
 
+// src/chains/solana/relayer-fee.ts
+function computeRelayerFee(amount, config) {
+  if (!Number.isInteger(config.bps) || config.bps < 0) {
+    throw new Error("bps must be a non-negative integer");
+  }
+  if (amount < 0n) {
+    throw new Error("amount must be a non-negative bigint");
+  }
+  if (typeof config.flatFloor !== "bigint" || config.flatFloor < 0n) {
+    throw new Error("flatFloor must be a non-negative bigint");
+  }
+  const bpsFee = amount * BigInt(config.bps) / 10000n;
+  return bpsFee > config.flatFloor ? bpsFee : config.flatFloor;
+}
+var init_relayer_fee = __esm({
+  "src/chains/solana/relayer-fee.ts"() {
+    "use strict";
+  }
+});
+
+// src/chains/solana/gasless-cashout.ts
+async function buildGaslessCashout(params) {
+  const {
+    connection,
+    stealthAddress,
+    ephemeralPublicKey,
+    viewingPrivateKey,
+    spendingPrivateKey,
+    destinationAddress,
+    mint,
+    relayerPublicKey,
+    relayerFeeAccount,
+    feeConfig,
+    version = "2"
+  } = params;
+  const stealthSigner = deriveStealthSigner({
+    stealthAddress,
+    ephemeralPublicKey,
+    viewingPrivateKey,
+    spendingPrivateKey,
+    version
+  });
+  const stealthPubkey = stealthSigner.publicKey;
+  const stealthATA = await (0, import_spl_token8.getAssociatedTokenAddress)(mint, stealthPubkey, true);
+  const destinationPubkey = new import_web317.PublicKey(destinationAddress);
+  const destinationATA = await (0, import_spl_token8.getAssociatedTokenAddress)(mint, destinationPubkey);
+  if (destinationATA.equals(stealthATA)) {
+    throw new Error(
+      "destinationAddress resolves to the stealth token account; choose a different destination"
+    );
+  }
+  let feeAccount;
+  try {
+    feeAccount = await (0, import_spl_token8.getAccount)(connection, relayerFeeAccount);
+  } catch {
+    throw new Error("relayerFeeAccount does not exist or is not a token account");
+  }
+  if (!feeAccount.mint.equals(mint)) {
+    throw new Error("relayerFeeAccount is not an associated token account for the given mint");
+  }
+  let balanceResp;
+  try {
+    balanceResp = await connection.getTokenAccountBalance(stealthATA);
+  } catch {
+    throw new Error(
+      `Stealth token account ${stealthATA.toBase58()} for mint ${mint.toBase58()} does not exist or holds no balance; nothing to cash out`
+    );
+  }
+  const grossAmount = BigInt(balanceResp.value.amount);
+  const relayerFee = computeRelayerFee(grossAmount, feeConfig);
+  if (relayerFee >= grossAmount) {
+    throw new Error(
+      `Relayer fee (${relayerFee}) equals or exceeds the claim amount (${grossAmount}); nothing left to forward`
+    );
+  }
+  const netAmount = grossAmount - relayerFee;
+  const transaction = new import_web317.Transaction();
+  transaction.add(
+    (0, import_spl_token8.createAssociatedTokenAccountIdempotentInstruction)(
+      relayerPublicKey,
+      // payer (relayer pays rent)
+      destinationATA,
+      destinationPubkey,
+      mint
+    )
+  );
+  transaction.add(
+    (0, import_spl_token8.createTransferInstruction)(stealthATA, relayerFeeAccount, stealthPubkey, relayerFee)
+  );
+  transaction.add(
+    (0, import_spl_token8.createTransferInstruction)(stealthATA, destinationATA, stealthPubkey, netAmount)
+  );
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+  transaction.recentBlockhash = blockhash;
+  transaction.lastValidBlockHeight = lastValidBlockHeight;
+  transaction.feePayer = relayerPublicKey;
+  stealthSigner.signTransaction(transaction);
+  return {
+    transaction,
+    stealthAddress,
+    destinationAddress,
+    grossAmount,
+    relayerFee,
+    netAmount,
+    blockhash,
+    lastValidBlockHeight
+  };
+}
+function detectCluster5(endpoint) {
+  if (endpoint.includes("devnet")) {
+    return "devnet";
+  }
+  if (endpoint.includes("testnet")) {
+    return "testnet";
+  }
+  if (endpoint.includes("localhost") || endpoint.includes("127.0.0.1")) {
+    return "localnet";
+  }
+  return "mainnet-beta";
+}
+async function submitGaslessCashout(params) {
+  const { connection, build, relayerKeypair, jitoRelayer, tipLamports } = params;
+  const { transaction, netAmount, relayerFee, destinationAddress } = build;
+  if (!transaction.feePayer || !transaction.feePayer.equals(relayerKeypair.publicKey)) {
+    throw new Error("relayerKeypair does not match the transaction fee-payer");
+  }
+  const relayerAlreadySigned = transaction.signatures.some(
+    (s) => s.publicKey.equals(relayerKeypair.publicKey) && s.signature !== null
+  );
+  if (!relayerAlreadySigned) {
+    transaction.partialSign(relayerKeypair);
+  }
+  const cluster = detectCluster5(connection.rpcEndpoint);
+  if (jitoRelayer) {
+    const relayed = await jitoRelayer.relayTransaction({
+      transaction,
+      tipLamports,
+      tipPayer: relayerKeypair,
+      waitForConfirmation: true
+    });
+    if (relayed.status !== "confirmed") {
+      throw new Error(
+        `Gasless cash-out via Jito did not confirm (status: ${relayed.status})` + (relayed.error ? `: ${relayed.error}` : "")
+      );
+    }
+    if (!relayed.signature) {
+      throw new Error("Gasless cash-out via Jito returned an empty transaction signature");
+    }
+    return {
+      txSignature: relayed.signature,
+      destinationAddress,
+      amount: netAmount,
+      relayerFee,
+      explorerUrl: getExplorerUrl(relayed.signature, cluster),
+      // Report the TRUE path: the relayer may have fallen back to direct submission.
+      viaJito: relayed.relayed
+    };
+  }
+  const txSignature = await connection.sendRawTransaction(transaction.serialize(), {
+    skipPreflight: false,
+    preflightCommitment: "confirmed"
+  });
+  const confirmation = await connection.confirmTransaction(
+    {
+      signature: txSignature,
+      blockhash: build.blockhash,
+      lastValidBlockHeight: build.lastValidBlockHeight
+    },
+    "confirmed"
+  );
+  if (confirmation.value.err) {
+    throw new Error(
+      `Gasless cash-out landed but failed on-chain: ${JSON.stringify(confirmation.value.err)}`
+    );
+  }
+  return {
+    txSignature,
+    destinationAddress,
+    amount: netAmount,
+    relayerFee,
+    explorerUrl: getExplorerUrl(txSignature, cluster),
+    viaJito: false
+  };
+}
+var import_web317, import_spl_token8;
+var init_gasless_cashout = __esm({
+  "src/chains/solana/gasless-cashout.ts"() {
+    "use strict";
+    import_web317 = require("@solana/web3.js");
+    import_spl_token8 = require("@solana/spl-token");
+    init_stealth_signer();
+    init_relayer_fee();
+    init_constants();
+  }
+});
+
 // src/chains/solana/index.ts
 var solana_exports = {};
 __export(solana_exports, {
@@ -13952,10 +14207,12 @@ __export(solana_exports, {
   batchGetTokenBalances: () => batchGetTokenBalances,
   batchResolveTokenMetadata: () => batchResolveTokenMetadata,
   batchScanForRecipients: () => batchScanForRecipients,
+  buildGaslessCashout: () => buildGaslessCashout,
   calculatePriorityFee: () => calculatePriorityFee,
   claimStealthPayment: () => claimStealthPayment,
   commitSPLToken: () => commitSPLToken,
   commitSolana: () => commitSolana,
+  computeRelayerFee: () => computeRelayerFee,
   computeViewingKeyHash: () => computeViewingKeyHash,
   computeViewingKeyHashFromPrivate: () => computeViewingKeyHashFromPrivate,
   createAddress: () => createAddress,
@@ -13976,6 +14233,7 @@ __export(solana_exports, {
   decryptWithViewing: () => decryptWithViewing2,
   deriveChildViewingKey: () => deriveChildViewingKey,
   deriveSolanaStealthKeys: () => deriveSolanaStealthKeys,
+  deriveStealthSigner: () => deriveStealthSigner,
   deriveViewingKeyFromSpending: () => deriveViewingKeyFromSpending,
   disposeEphemeralKeypairs: () => disposeEphemeralKeypairs,
   encryptForViewing: () => encryptForViewing2,
@@ -14025,7 +14283,9 @@ __export(solana_exports, {
   sendPrivateSPLTransfer: () => sendPrivateSPLTransfer,
   sendSOLTransfer: () => sendSOLTransfer,
   shieldedTransfer: () => shieldedTransfer,
+  signEd25519WithScalar: () => signEd25519WithScalar,
   solToLamports: () => solToLamports,
+  submitGaslessCashout: () => submitGaslessCashout,
   subtractBlindingsSolana: () => subtractBlindingsSolana,
   subtractCommitmentsSolana: () => subtractCommitmentsSolana,
   toAddress: () => toAddress,
@@ -14069,6 +14329,9 @@ var init_solana = __esm({
     init_anchor_transfer();
     init_kit_compat();
     init_sunspot_verifier();
+    init_gasless_cashout();
+    init_relayer_fee();
+    init_stealth_signer();
   }
 });
 
@@ -14519,10 +14782,10 @@ var init_lib_es2 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@ledgerhq+hw-transport@6.35.2/node_modules/@ledgerhq/hw-transport/lib-es/Transport.js
+// ../../node_modules/.pnpm/@ledgerhq+hw-transport@6.35.3/node_modules/@ledgerhq/hw-transport/lib-es/Transport.js
 var import_events, DEFAULT_LOG_TYPE, Transport;
 var init_Transport = __esm({
-  "../../node_modules/.pnpm/@ledgerhq+hw-transport@6.35.2/node_modules/@ledgerhq/hw-transport/lib-es/Transport.js"() {
+  "../../node_modules/.pnpm/@ledgerhq+hw-transport@6.35.3/node_modules/@ledgerhq/hw-transport/lib-es/Transport.js"() {
     "use strict";
     import_events = __toESM(require("events"));
     init_lib_es();
@@ -14851,7 +15114,7 @@ var init_Transport = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@ledgerhq+devices@8.14.2/node_modules/@ledgerhq/devices/lib-es/hid-framing.js
+// ../../node_modules/.pnpm/@ledgerhq+devices@8.15.0/node_modules/@ledgerhq/devices/lib-es/hid-framing.js
 function asUInt16BE(value) {
   const b = Buffer.alloc(2);
   b.writeUInt16BE(value, 0);
@@ -14859,7 +15122,7 @@ function asUInt16BE(value) {
 }
 var Tag, initialAcc, createHIDframing, hid_framing_default;
 var init_hid_framing = __esm({
-  "../../node_modules/.pnpm/@ledgerhq+devices@8.14.2/node_modules/@ledgerhq/devices/lib-es/hid-framing.js"() {
+  "../../node_modules/.pnpm/@ledgerhq+devices@8.15.0/node_modules/@ledgerhq/devices/lib-es/hid-framing.js"() {
     "use strict";
     init_lib_es();
     Tag = 5;
@@ -16195,7 +16458,7 @@ var require_range = __commonJS({
 var require_comparator = __commonJS({
   "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/comparator.js"(exports2, module2) {
     "use strict";
-    var ANY = Symbol("SemVer ANY");
+    var ANY = /* @__PURE__ */ Symbol("SemVer ANY");
     var Comparator = class _Comparator {
       static get ANY() {
         return ANY;
@@ -16874,10 +17137,10 @@ var require_semver2 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@ledgerhq+devices@8.14.2/node_modules/@ledgerhq/devices/lib-es/index.js
+// ../../node_modules/.pnpm/@ledgerhq+devices@8.15.0/node_modules/@ledgerhq/devices/lib-es/index.js
 var import_semver, DeviceModelId, devices, productMap, devicesList, ledgerUSBVendorId, identifyUSBProductId, bluetoothServices, serviceUuidToInfos;
 var init_lib_es3 = __esm({
-  "../../node_modules/.pnpm/@ledgerhq+devices@8.14.2/node_modules/@ledgerhq/devices/lib-es/index.js"() {
+  "../../node_modules/.pnpm/@ledgerhq+devices@8.15.0/node_modules/@ledgerhq/devices/lib-es/index.js"() {
     "use strict";
     import_semver = __toESM(require_semver2());
     (function(DeviceModelId2) {
@@ -16936,7 +17199,7 @@ var init_lib_es3 = __esm({
         usbOnly: true,
         memorySize: 1533 * 1024,
         masks: [856686592],
-        getBlockSize: (_firmwareVersion) => 32
+        getBlockSize: (_firmwareVersion) => 512
       },
       [DeviceModelId.apex]: {
         id: DeviceModelId.apex,
@@ -16946,7 +17209,7 @@ var init_lib_es3 = __esm({
         usbOnly: false,
         memorySize: 1533 * 1024,
         masks: [859832320],
-        getBlockSize: (_firmwareVersion) => 32,
+        getBlockSize: (_firmwareVersion) => 512,
         bluetoothSpec: [
           {
             serviceUuid: "13d63400-2c97-8004-0000-4c6564676572",
@@ -16964,7 +17227,7 @@ var init_lib_es3 = __esm({
         usbOnly: false,
         memorySize: 1533 * 1024,
         masks: [857735168],
-        getBlockSize: (_firmwareVersion) => 32,
+        getBlockSize: (_firmwareVersion) => 512,
         bluetoothSpec: [
           {
             serviceUuid: "13d63400-2c97-6004-0000-4c6564676572",
@@ -16982,7 +17245,7 @@ var init_lib_es3 = __esm({
         usbOnly: false,
         memorySize: 1533 * 1024,
         masks: [858783744],
-        getBlockSize: (_firmwareVersion) => 32,
+        getBlockSize: (_firmwareVersion) => 512,
         bluetoothSpec: [
           {
             serviceUuid: "13d63400-2c97-3004-0000-4c6564676572",
@@ -17030,7 +17293,7 @@ var init_lib_es3 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.34.2/node_modules/@ledgerhq/hw-transport-webusb/lib-es/webusb.js
+// ../../node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.34.3/node_modules/@ledgerhq/hw-transport-webusb/lib-es/webusb.js
 async function requestLedgerDevice() {
   const device = await navigator.usb.requestDevice({
     filters: ledgerDevices
@@ -17049,7 +17312,7 @@ async function getFirstLedgerDevice() {
 }
 var ledgerDevices, isSupported;
 var init_webusb = __esm({
-  "../../node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.34.2/node_modules/@ledgerhq/hw-transport-webusb/lib-es/webusb.js"() {
+  "../../node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.34.3/node_modules/@ledgerhq/hw-transport-webusb/lib-es/webusb.js"() {
     "use strict";
     init_lib_es3();
     ledgerDevices = [
@@ -17061,7 +17324,7 @@ var init_webusb = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.34.2/node_modules/@ledgerhq/hw-transport-webusb/lib-es/TransportWebUSB.js
+// ../../node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.34.3/node_modules/@ledgerhq/hw-transport-webusb/lib-es/TransportWebUSB.js
 var TransportWebUSB_exports = {};
 __export(TransportWebUSB_exports, {
   default: () => TransportWebUSB
@@ -17075,7 +17338,7 @@ async function gracefullyResetDevice(device) {
 }
 var configurationValue, endpointNumber, TransportWebUSB;
 var init_TransportWebUSB = __esm({
-  "../../node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.34.2/node_modules/@ledgerhq/hw-transport-webusb/lib-es/TransportWebUSB.js"() {
+  "../../node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.34.3/node_modules/@ledgerhq/hw-transport-webusb/lib-es/TransportWebUSB.js"() {
     "use strict";
     init_Transport();
     init_hid_framing();
@@ -18237,7 +18500,7 @@ __export(browser_exports, {
   NEARIntentsAdapter: () => NEARIntentsAdapter,
   NEARIntentsBackend: () => NEARIntentsBackend,
   NEAR_DEFAULT_GAS: () => DEFAULT_GAS,
-  NEAR_ED25519_ORDER: () => ED25519_ORDER5,
+  NEAR_ED25519_ORDER: () => ED25519_ORDER4,
   NEAR_EXPLORER_URLS: () => NEAR_EXPLORER_URLS,
   NEAR_FEE_CONTRACTS: () => NEAR_FEE_CONTRACTS,
   NEAR_IMPLICIT_ACCOUNT_LENGTH: () => NEAR_IMPLICIT_ACCOUNT_LENGTH,
@@ -18348,6 +18611,7 @@ __export(browser_exports, {
   bpsToPercent: () => bpsToPercent,
   browserBytesToHex: () => bytesToHex18,
   browserHexToBytes: () => hexToBytes15,
+  buildGaslessCashout: () => buildGaslessCashout,
   cacheKeyGenerator: () => cacheKeyGenerator,
   calculateFeeForSwap: () => calculateFeeForSwap,
   calculatePrivacyScore: () => calculatePrivacyScore,
@@ -18370,6 +18634,7 @@ __export(browser_exports, {
   computeAttestationHash: () => computeAttestationHash,
   computeNEARViewingKeyHash: () => computeNEARViewingKeyHash,
   computeNEARViewingKeyHashFromPrivate: () => computeNEARViewingKeyHashFromPrivate,
+  computeRelayerFee: () => computeRelayerFee,
   computeTweakedKey: () => computeTweakedKey,
   configureLogger: () => configureLogger,
   convertFromSIP: () => convertFromSIP,
@@ -18474,6 +18739,7 @@ __export(browser_exports, {
   deriveSecp256k1StealthPrivateKeyV1: () => deriveSecp256k1StealthPrivateKeyV1,
   deriveStealthPrivateKey: () => deriveStealthPrivateKey,
   deriveStealthPrivateKeyV1: () => deriveStealthPrivateKeyV1,
+  deriveStealthSigner: () => deriveStealthSigner,
   deriveSuiStealthPrivateKey: () => deriveSuiStealthPrivateKey,
   deriveTraditionalNullifier: () => deriveTraditionalNullifier,
   deriveViewingKey: () => deriveViewingKey,
@@ -18671,11 +18937,13 @@ __export(browser_exports, {
   serializePayment: () => serializePayment,
   setLogLevel: () => setLogLevel,
   signAttestationMessage: () => signAttestationMessage,
+  signEd25519WithScalar: () => signEd25519WithScalar,
   silenceLogger: () => silenceLogger,
   solanaAddressToEd25519PublicKey: () => solanaAddressToEd25519PublicKey,
   solanaOptimizations: () => optimizations_exports,
   solanaPublicKeyToHex: () => solanaPublicKeyToHex,
   stealthKeyToCosmosAddress: () => stealthKeyToCosmosAddress,
+  submitGaslessCashout: () => submitGaslessCashout,
   subtractBlindings: () => subtractBlindings,
   subtractBlindingsNEAR: () => subtractBlindingsNEAR,
   subtractCommitments: () => subtractCommitments,
@@ -21357,7 +21625,7 @@ var SIP = class {
     }
     const { sendPrivateSPLTransfer: sendPrivateSPLTransfer2 } = await Promise.resolve().then(() => (init_solana(), solana_exports));
     const { PublicKey: SolanaPublicKey } = await import("@solana/web3.js");
-    const { getAssociatedTokenAddress: getAssociatedTokenAddress8 } = await import("@solana/spl-token");
+    const { getAssociatedTokenAddress: getAssociatedTokenAddress9 } = await import("@solana/spl-token");
     const { SOLANA_TOKEN_MINTS: SOLANA_TOKEN_MINTS3 } = await Promise.resolve().then(() => (init_constants(), constants_exports));
     let mint;
     if (params.token in SOLANA_TOKEN_MINTS3) {
@@ -21365,7 +21633,7 @@ var SIP = class {
     } else {
       mint = new SolanaPublicKey(params.token);
     }
-    const senderTokenAccount = await getAssociatedTokenAddress8(
+    const senderTokenAccount = await getAssociatedTokenAddress9(
       mint,
       params.sender
     );
@@ -21414,7 +21682,7 @@ init_stealth2();
 // src/cosmos/stealth.ts
 var import_sha2569 = require("@noble/hashes/sha256");
 var import_ripemd160 = require("@noble/hashes/ripemd160");
-var import_utils29 = require("@noble/hashes/utils");
+var import_utils30 = require("@noble/hashes/utils");
 var import_base3 = require("@scure/base");
 init_stealth2();
 init_errors();
@@ -21498,14 +21766,14 @@ var CosmosStealthService = class {
       );
     }
     const metaAddress = {
-      spendingKey: `0x${(0, import_utils29.bytesToHex)(spendingPubKey)}`,
-      viewingKey: `0x${(0, import_utils29.bytesToHex)(viewingPubKey)}`,
+      spendingKey: `0x${(0, import_utils30.bytesToHex)(spendingPubKey)}`,
+      viewingKey: `0x${(0, import_utils30.bytesToHex)(viewingPubKey)}`,
       chain: "ethereum"
       // Use ethereum for secp256k1 generation
     };
     const { stealthAddress, sharedSecret } = generateStealthAddress(metaAddress);
     const cosmosAddress = this.stealthKeyToCosmosAddress(
-      (0, import_utils29.hexToBytes)(stealthAddress.address.slice(2)),
+      (0, import_utils30.hexToBytes)(stealthAddress.address.slice(2)),
       CHAIN_PREFIXES[chain]
     );
     return {
@@ -21533,8 +21801,8 @@ var CosmosStealthService = class {
    * ```
    */
   generateStealthAddressFromMeta(recipientMetaAddress, chain) {
-    const spendingPubKey = (0, import_utils29.hexToBytes)(recipientMetaAddress.spendingKey.slice(2));
-    const viewingPubKey = (0, import_utils29.hexToBytes)(recipientMetaAddress.viewingKey.slice(2));
+    const spendingPubKey = (0, import_utils30.hexToBytes)(recipientMetaAddress.spendingKey.slice(2));
+    const viewingPubKey = (0, import_utils30.hexToBytes)(recipientMetaAddress.viewingKey.slice(2));
     return this.generateStealthAddress(spendingPubKey, viewingPubKey, chain);
   }
   /**
@@ -21712,7 +21980,7 @@ function isValidCosmosAddress(address, expectedChain) {
 }
 
 // src/cosmos/ibc-stealth.ts
-var import_utils30 = require("@noble/hashes/utils");
+var import_utils31 = require("@noble/hashes/utils");
 var import_secp256k14 = require("@noble/curves/secp256k1");
 var import_sha25610 = require("@noble/hashes/sha256");
 init_errors();
@@ -21736,7 +22004,7 @@ var ProofGenerationError = class extends Error {
 
 // src/proofs/mock.ts
 var import_sha25611 = require("@noble/hashes/sha256");
-var import_utils31 = require("@noble/hashes/utils");
+var import_utils32 = require("@noble/hashes/utils");
 init_errors();
 var log3 = createLogger("proofs/mock");
 var MOCK_PROOF_PREFIX = "0x4d4f434b";
@@ -21913,16 +22181,16 @@ var MockProofProvider = class {
       (_, v) => typeof v === "bigint" ? v.toString() : v
     );
     const hash2 = (0, import_sha25611.sha256)(new TextEncoder().encode(input));
-    const random = (0, import_utils31.randomBytes)(16);
+    const random = (0, import_utils32.randomBytes)(16);
     const combined = new Uint8Array(4 + hash2.length + random.length);
     combined.set(new TextEncoder().encode("MOCK"), 0);
     combined.set(hash2, 4);
     combined.set(random, 4 + hash2.length);
-    return `${MOCK_PROOF_PREFIX}${(0, import_utils31.bytesToHex)(combined.slice(4))}`;
+    return `${MOCK_PROOF_PREFIX}${(0, import_utils32.bytesToHex)(combined.slice(4))}`;
   }
   hashToHex(data) {
     const hash2 = (0, import_sha25611.sha256)(new TextEncoder().encode(data));
-    return `0x${(0, import_utils31.bytesToHex)(hash2)}`;
+    return `0x${(0, import_utils32.bytesToHex)(hash2)}`;
   }
 };
 
@@ -22657,46 +22925,46 @@ var ComplianceProofProvider = class {
   }
   async hashViewingKey(viewingKey) {
     const { sha256: sha25642 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex65 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex64 } = await import("@noble/hashes/utils");
     const keyString = typeof viewingKey === "string" ? viewingKey : JSON.stringify(viewingKey);
     const encoder = new TextEncoder();
     const keyBytes = encoder.encode(keyString);
-    return bytesToHex65(sha25642(keyBytes));
+    return bytesToHex64(sha25642(keyBytes));
   }
   async computeDecryptionCommitment(viewingKey, encryptedData) {
     const { sha256: sha25642 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex65 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex64 } = await import("@noble/hashes/utils");
     const keyHash = await this.hashViewingKey(viewingKey);
     const keyBytes = this.hexToBytes(keyHash);
     const preimage = new Uint8Array([...keyBytes, ...encryptedData.slice(0, 32)]);
-    return bytesToHex65(sha25642(preimage));
+    return bytesToHex64(sha25642(preimage));
   }
   async computeAuditorHash(auditorPublicKey, transactionHash) {
     const { sha256: sha25642 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex65 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex64 } = await import("@noble/hashes/utils");
     const auditorBytes = this.hexToBytes(auditorPublicKey.replace("0x", "").padStart(64, "0"));
     const txBytes = this.hexToBytes(transactionHash.replace("0x", "").padStart(64, "0"));
     const preimage = new Uint8Array([...auditorBytes, ...txBytes]);
-    return bytesToHex65(sha25642(preimage));
+    return bytesToHex64(sha25642(preimage));
   }
   async computeAddressCommitment(address, blinding) {
     const { sha256: sha25642 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex65 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex64 } = await import("@noble/hashes/utils");
     const addressBytes = this.hexToBytes(address.replace("0x", "").padStart(64, "0"));
     const preimage = new Uint8Array([...addressBytes, ...blinding.slice(0, 32)]);
-    return bytesToHex65(sha25642(preimage));
+    return bytesToHex64(sha25642(preimage));
   }
   async computeNonMembershipProof(senderAddress, recipientAddress, _sanctionsListRoot) {
     const { sha256: sha25642 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex65 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex64 } = await import("@noble/hashes/utils");
     const senderBytes = this.hexToBytes(senderAddress.replace("0x", "").padStart(64, "0"));
     const recipientBytes = this.hexToBytes(recipientAddress.replace("0x", "").padStart(64, "0"));
     const preimage = new Uint8Array([...senderBytes, ...recipientBytes]);
-    return bytesToHex65(sha25642(preimage));
+    return bytesToHex64(sha25642(preimage));
   }
   async computeBalanceCommitment(balance, blinding) {
     const { sha256: sha25642 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex65 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex64 } = await import("@noble/hashes/utils");
     const balanceBytes = new Uint8Array(8);
     let v = balance;
     for (let i = 7; i >= 0; i--) {
@@ -22704,11 +22972,11 @@ var ComplianceProofProvider = class {
       v = v >> 8n;
     }
     const preimage = new Uint8Array([...balanceBytes, ...blinding.slice(0, 32)]);
-    return bytesToHex65(sha25642(preimage));
+    return bytesToHex64(sha25642(preimage));
   }
   async generateComplianceProofBytes(type, publicInputs) {
     const { sha256: sha25642 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex65 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex64 } = await import("@noble/hashes/utils");
     const circuitId = COMPLIANCE_CIRCUIT_IDS[type];
     const encoder = new TextEncoder();
     const inputBytes = publicInputs.flatMap((pi) => Array.from(this.hexToBytes(pi.replace("0x", ""))));
@@ -22719,7 +22987,7 @@ var ComplianceProofProvider = class {
     const hash2 = sha25642(preimage);
     let proofBytes = "";
     for (let i = 0; i < 8; i++) {
-      proofBytes += bytesToHex65(sha25642(new Uint8Array([...hash2, i])));
+      proofBytes += bytesToHex64(sha25642(new Uint8Array([...hash2, i])));
     }
     return proofBytes;
   }
@@ -22747,7 +23015,7 @@ var ComplianceProofProvider = class {
 };
 
 // src/proofs/aggregator.ts
-var import_utils32 = require("@noble/hashes/utils");
+var import_utils33 = require("@noble/hashes/utils");
 var import_types13 = require("@sip-protocol/types");
 var DEFAULT_AGGREGATOR_CONFIG = {
   maxProofs: 100,
@@ -22765,8 +23033,8 @@ var DEFAULT_AGGREGATOR_CONFIG = {
   verbose: false
 };
 function generateId(prefix) {
-  const bytes = (0, import_utils32.randomBytes)(8);
-  return `${prefix}-${(0, import_utils32.bytesToHex)(bytes)}`;
+  const bytes = (0, import_utils33.randomBytes)(8);
+  return `${prefix}-${(0, import_utils33.bytesToHex)(bytes)}`;
 }
 function computeProofHash(proofs) {
   const data = proofs.map((p) => p.proof).join("");
@@ -23166,10 +23434,10 @@ var ProofAggregator = class {
   async simulateRecursiveMerge(proofs, targetSystem, depth) {
     await delay(proofs.length * 50);
     const combinedInputs = proofs.flatMap((p) => p.publicInputs);
-    const proofBytes = (0, import_utils32.randomBytes)(256);
+    const proofBytes = (0, import_utils33.randomBytes)(256);
     return {
       id: generateId(`recursive-${depth}`),
-      proof: `0x${(0, import_utils32.bytesToHex)(proofBytes)}`,
+      proof: `0x${(0, import_utils33.bytesToHex)(proofBytes)}`,
       publicInputs: combinedInputs.slice(0, 10),
       metadata: {
         system: targetSystem,
@@ -23384,7 +23652,7 @@ function createProofAggregator(config) {
 }
 
 // src/proofs/verifier.ts
-var import_utils33 = require("@noble/hashes/utils");
+var import_utils34 = require("@noble/hashes/utils");
 var DEFAULT_PIPELINE_CONFIG = {
   enableParallel: true,
   maxConcurrent: 4,
@@ -23398,7 +23666,7 @@ var DEFAULT_PIPELINE_CONFIG = {
   generateVerificationProof: false
 };
 function generateId2(prefix) {
-  return `${prefix}-${(0, import_utils33.bytesToHex)((0, import_utils33.randomBytes)(8))}`;
+  return `${prefix}-${(0, import_utils34.bytesToHex)((0, import_utils34.randomBytes)(8))}`;
 }
 function computeLinkHash(sourceProof, targetProof) {
   const combinedData = sourceProof.proof + targetProof.proof;
@@ -24378,7 +24646,7 @@ function createCrossSystemValidator(options) {
 }
 
 // src/proofs/orchestrator.ts
-var import_utils34 = require("@noble/hashes/utils");
+var import_utils35 = require("@noble/hashes/utils");
 var import_types14 = require("@sip-protocol/types");
 var DEFAULT_ORCHESTRATOR_CONFIG = {
   maxRetries: 3,
@@ -24434,7 +24702,7 @@ var BUILTIN_TEMPLATES = [
   }
 ];
 function generateId3(prefix) {
-  return `${prefix}-${(0, import_utils34.bytesToHex)((0, import_utils34.randomBytes)(8))}`;
+  return `${prefix}-${(0, import_utils35.bytesToHex)((0, import_utils35.randomBytes)(8))}`;
 }
 function delay2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -24985,12 +25253,12 @@ var IncompatibleSystemsError = class extends ProofCompositionError {
 };
 
 // src/proofs/composer/base.ts
-var import_utils35 = require("@noble/hashes/utils");
 var import_utils36 = require("@noble/hashes/utils");
+var import_utils37 = require("@noble/hashes/utils");
 var import_types16 = require("@sip-protocol/types");
 function generateId4(prefix) {
-  const bytes = (0, import_utils35.randomBytes)(8);
-  return `${prefix}-${(0, import_utils36.bytesToHex)(bytes)}`;
+  const bytes = (0, import_utils36.randomBytes)(8);
+  return `${prefix}-${(0, import_utils37.bytesToHex)(bytes)}`;
 }
 function computeProofHash2(proofs) {
   const data = proofs.map((p) => p.proof).join("");
@@ -25635,7 +25903,7 @@ var BaseProofComposer = class {
 };
 
 // src/proofs/providers/halo2.ts
-var import_utils37 = require("@noble/hashes/utils");
+var import_utils38 = require("@noble/hashes/utils");
 var import_types17 = require("@sip-protocol/types");
 var DEFAULT_HALO2_CONFIG = {
   artifactsPath: "",
@@ -25836,8 +26104,8 @@ var Halo2Provider = class {
   async generateMockProof(request, circuit) {
     const simulatedTimeMs = Math.min(100 + circuit.k * 10, 2e3);
     await this.delay(simulatedTimeMs);
-    const proofBytes = (0, import_utils37.randomBytes)(256);
-    const proofHex = `0x${(0, import_utils37.bytesToHex)(proofBytes)}`;
+    const proofBytes = (0, import_utils38.randomBytes)(256);
+    const proofHex = `0x${(0, import_utils38.bytesToHex)(proofBytes)}`;
     const publicInputs = Object.values(request.publicInputs).map((v) => {
       if (typeof v === "string" && v.startsWith("0x")) {
         return v;
@@ -25848,7 +26116,7 @@ var Halo2Provider = class {
       return `0x${Buffer.from(String(v)).toString("hex")}`;
     });
     return {
-      id: `halo2-proof-${Date.now()}-${(0, import_utils37.randomBytes)(4).reduce((a, b) => a + b.toString(16), "")}`,
+      id: `halo2-proof-${Date.now()}-${(0, import_utils38.randomBytes)(4).reduce((a, b) => a + b.toString(16), "")}`,
       proof: proofHex,
       publicInputs,
       metadata: {
@@ -25916,7 +26184,7 @@ var Halo2Provider = class {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
   generateProviderId() {
-    return (0, import_utils37.bytesToHex)((0, import_utils37.randomBytes)(4));
+    return (0, import_utils38.bytesToHex)((0, import_utils38.randomBytes)(4));
   }
 };
 function createHalo2Provider(config) {
@@ -25947,7 +26215,7 @@ function createOrchardProvider() {
 }
 
 // src/proofs/providers/kimchi.ts
-var import_utils38 = require("@noble/hashes/utils");
+var import_utils39 = require("@noble/hashes/utils");
 var import_types18 = require("@sip-protocol/types");
 var DEFAULT_KIMCHI_CONFIG = {
   circuits: [],
@@ -26096,7 +26364,7 @@ var KimchiProvider = class {
       console.log(`[KimchiProvider] Compiling circuit: ${circuitId}`);
     }
     await this.delay(100 + circuit.gateCount * 0.1);
-    const vkHash = `0x${(0, import_utils38.bytesToHex)((0, import_utils38.randomBytes)(32))}`;
+    const vkHash = `0x${(0, import_utils39.bytesToHex)((0, import_utils39.randomBytes)(32))}`;
     this._compiledCircuits.set(circuitId, {
       compiled: true,
       vkHash
@@ -26162,8 +26430,8 @@ var KimchiProvider = class {
   async generateMockProof(request, circuit) {
     const simulatedTimeMs = Math.min(200 + circuit.gateCount * 0.5, 5e3);
     await this.delay(simulatedTimeMs);
-    const proofBytes = (0, import_utils38.randomBytes)(KIMCHI_PROOF_SIZE);
-    const proofHex = `0x${(0, import_utils38.bytesToHex)(proofBytes)}`;
+    const proofBytes = (0, import_utils39.randomBytes)(KIMCHI_PROOF_SIZE);
+    const proofHex = `0x${(0, import_utils39.bytesToHex)(proofBytes)}`;
     const publicInputs = Object.values(request.publicInputs).map((v) => {
       if (typeof v === "string" && v.startsWith("0x")) {
         return v;
@@ -26175,7 +26443,7 @@ var KimchiProvider = class {
     });
     const vkHash = this._compiledCircuits.get(request.circuitId)?.vkHash;
     return {
-      id: `kimchi-proof-${Date.now()}-${(0, import_utils38.randomBytes)(4).reduce((a, b) => a + b.toString(16), "")}`,
+      id: `kimchi-proof-${Date.now()}-${(0, import_utils39.randomBytes)(4).reduce((a, b) => a + b.toString(16), "")}`,
       proof: proofHex,
       publicInputs,
       verificationKey: vkHash,
@@ -26268,11 +26536,11 @@ var KimchiProvider = class {
       console.log(`[KimchiProvider] Merging ${proofs.length} proofs recursively`);
     }
     await this.delay(proofs.length * 100);
-    const mergedProofBytes = (0, import_utils38.randomBytes)(KIMCHI_PROOF_SIZE);
+    const mergedProofBytes = (0, import_utils39.randomBytes)(KIMCHI_PROOF_SIZE);
     const combinedInputs = proofs.flatMap((p) => p.publicInputs);
     return {
       id: `kimchi-merged-${Date.now()}`,
-      proof: `0x${(0, import_utils38.bytesToHex)(mergedProofBytes)}`,
+      proof: `0x${(0, import_utils39.bytesToHex)(mergedProofBytes)}`,
       publicInputs: combinedInputs.slice(0, 10),
       // Limit public inputs
       metadata: {
@@ -26293,7 +26561,7 @@ var KimchiProvider = class {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
   generateProviderId() {
-    return (0, import_utils38.bytesToHex)((0, import_utils38.randomBytes)(4));
+    return (0, import_utils39.bytesToHex)((0, import_utils39.randomBytes)(4));
   }
 };
 function createKimchiProvider(config) {
@@ -27404,7 +27672,7 @@ var DEFAULT_WARMING_CONFIG = {
 
 // src/proofs/cache/key-generator.ts
 var import_sha25612 = require("@noble/hashes/sha256");
-var import_utils39 = require("@noble/hashes/utils");
+var import_utils40 = require("@noble/hashes/utils");
 var KEY_SEPARATOR = ":";
 var KEY_PREFIX = "sip-proof";
 var KEY_VERSION = "v1";
@@ -27426,7 +27694,7 @@ function canonicalize(value) {
     return value.toString();
   }
   if (value instanceof Uint8Array) {
-    return `bytes:${(0, import_utils39.bytesToHex)(value)}`;
+    return `bytes:${(0, import_utils40.bytesToHex)(value)}`;
   }
   if (Array.isArray(value)) {
     return `[${value.map(canonicalize).join(",")}]`;
@@ -27489,7 +27757,7 @@ var CacheKeyGenerator = class {
   hashInputs(inputs) {
     const canonical = canonicalize(inputs);
     const hash2 = (0, import_sha25612.sha256)(new TextEncoder().encode(canonical));
-    return (0, import_utils39.bytesToHex)(hash2);
+    return (0, import_utils40.bytesToHex)(hash2);
   }
   /**
    * Generate a cache key from raw inputs
@@ -28934,11 +29202,11 @@ var CHAIN_NUMERIC_IDS = {
 // src/oracle/verification.ts
 var import_ed255199 = require("@noble/curves/ed25519");
 var import_sha25614 = require("@noble/hashes/sha256");
-var import_utils41 = require("@noble/hashes/utils");
+var import_utils42 = require("@noble/hashes/utils");
 
 // src/oracle/serialization.ts
 var import_sha25613 = require("@noble/hashes/sha256");
-var import_utils40 = require("@noble/hashes/utils");
+var import_utils41 = require("@noble/hashes/utils");
 init_errors();
 function serializeAttestationMessage(message) {
   const buffer = new Uint8Array(197);
@@ -28982,19 +29250,19 @@ function deserializeAttestationMessage(bytes) {
   const version = bytes[offset++];
   const chainId = view.getUint32(offset, false);
   offset += 4;
-  const intentHash = `0x${(0, import_utils40.bytesToHex)(bytes.slice(offset, offset + 32))}`;
+  const intentHash = `0x${(0, import_utils41.bytesToHex)(bytes.slice(offset, offset + 32))}`;
   offset += 32;
-  const recipient = `0x${(0, import_utils40.bytesToHex)(bytes.slice(offset, offset + 32))}`;
+  const recipient = `0x${(0, import_utils41.bytesToHex)(bytes.slice(offset, offset + 32))}`;
   offset += 32;
   const amount = bytesToBigint(bytes.slice(offset, offset + 16));
   offset += 16;
-  const assetId = `0x${(0, import_utils40.bytesToHex)(bytes.slice(offset, offset + 32))}`;
+  const assetId = `0x${(0, import_utils41.bytesToHex)(bytes.slice(offset, offset + 32))}`;
   offset += 32;
-  const txHash = `0x${(0, import_utils40.bytesToHex)(bytes.slice(offset, offset + 32))}`;
+  const txHash = `0x${(0, import_utils41.bytesToHex)(bytes.slice(offset, offset + 32))}`;
   offset += 32;
   const blockNumber = view.getBigUint64(offset, false);
   offset += 8;
-  const blockHash = `0x${(0, import_utils40.bytesToHex)(bytes.slice(offset, offset + 32))}`;
+  const blockHash = `0x${(0, import_utils41.bytesToHex)(bytes.slice(offset, offset + 32))}`;
   offset += 32;
   const timestamp = Number(view.getBigUint64(offset, false));
   return {
@@ -29011,7 +29279,7 @@ function deserializeAttestationMessage(bytes) {
   };
 }
 function computeAttestationHash(message) {
-  const domain = (0, import_utils40.utf8ToBytes)(ORACLE_DOMAIN);
+  const domain = (0, import_utils41.utf8ToBytes)(ORACLE_DOMAIN);
   const messageBytes = serializeAttestationMessage(message);
   const toHash = new Uint8Array(domain.length + messageBytes.length);
   toHash.set(domain, 0);
@@ -29027,7 +29295,7 @@ function getChainNumericId(chain) {
 }
 function normalizeToBytes(hex, length, field) {
   const stripped = hex.startsWith("0x") ? hex.slice(2) : hex;
-  const bytes = (0, import_utils40.hexToBytes)(stripped);
+  const bytes = (0, import_utils41.hexToBytes)(stripped);
   if (bytes.length === length) {
     return bytes;
   }
@@ -29060,9 +29328,9 @@ function bytesToBigint(bytes) {
 
 // src/oracle/verification.ts
 function deriveOracleId(publicKey) {
-  const keyBytes = typeof publicKey === "string" ? (0, import_utils41.hexToBytes)(publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey) : publicKey;
+  const keyBytes = typeof publicKey === "string" ? (0, import_utils42.hexToBytes)(publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey) : publicKey;
   const hash2 = (0, import_sha25614.sha256)(keyBytes);
-  return `0x${(0, import_utils41.bytesToHex)(hash2)}`;
+  return `0x${(0, import_utils42.bytesToHex)(hash2)}`;
 }
 function verifyAttestation(attestation, registry) {
   const { message, signatures } = attestation;
@@ -29092,10 +29360,10 @@ function verifyAttestation(attestation, registry) {
       continue;
     }
     try {
-      const publicKeyBytes = (0, import_utils41.hexToBytes)(
+      const publicKeyBytes = (0, import_utils42.hexToBytes)(
         oracle.publicKey.startsWith("0x") ? oracle.publicKey.slice(2) : oracle.publicKey
       );
-      const signatureBytes = (0, import_utils41.hexToBytes)(
+      const signatureBytes = (0, import_utils42.hexToBytes)(
         sig.signature.startsWith("0x") ? sig.signature.slice(2) : sig.signature
       );
       const isValid = import_ed255199.ed25519.verify(signatureBytes, messageHash, publicKeyBytes);
@@ -29120,10 +29388,10 @@ function verifyAttestation(attestation, registry) {
 }
 function verifyOracleSignature(signature, messageHash, oracle) {
   try {
-    const publicKeyBytes = (0, import_utils41.hexToBytes)(
+    const publicKeyBytes = (0, import_utils42.hexToBytes)(
       oracle.publicKey.startsWith("0x") ? oracle.publicKey.slice(2) : oracle.publicKey
     );
-    const signatureBytes = (0, import_utils41.hexToBytes)(
+    const signatureBytes = (0, import_utils42.hexToBytes)(
       signature.signature.startsWith("0x") ? signature.signature.slice(2) : signature.signature
     );
     return import_ed255199.ed25519.verify(signatureBytes, messageHash, publicKeyBytes);
@@ -29137,7 +29405,7 @@ function signAttestationMessage(messageHash, privateKey) {
   const oracleId = deriveOracleId(publicKey);
   return {
     oracleId,
-    signature: `0x${(0, import_utils41.bytesToHex)(signature)}`
+    signature: `0x${(0, import_utils42.bytesToHex)(signature)}`
   };
 }
 function createOracleRegistry(config = {}) {
@@ -29379,7 +29647,7 @@ var import_types87 = require("@sip-protocol/types");
 
 // src/solver/mock-solver.ts
 var import_types24 = require("@sip-protocol/types");
-var import_utils42 = require("@noble/hashes/utils");
+var import_utils43 = require("@noble/hashes/utils");
 var MockSolver = class {
   info;
   capabilities;
@@ -29461,7 +29729,7 @@ var MockSolver = class {
     const spreadAmount = baseOutput * BigInt(Math.floor(this.spreadPercent * 1e4)) / 10000n;
     const outputAmount = baseOutput + spreadAmount;
     const feeAmount = outputAmount * BigInt(Math.floor(this.feePercent * 1e4)) / 10000n;
-    const quoteId = `quote-${(0, import_utils42.bytesToHex)((0, import_utils42.randomBytes)(8))}`;
+    const quoteId = `quote-${(0, import_utils43.bytesToHex)((0, import_utils43.randomBytes)(8))}`;
     const now = Math.floor(Date.now() / 1e3);
     const quote = {
       quoteId,
@@ -29472,7 +29740,7 @@ var MockSolver = class {
       expiry: now + 60,
       // Quote valid for 1 minute
       fee: feeAmount,
-      signature: `0x${(0, import_utils42.bytesToHex)((0, import_utils42.randomBytes)(64))}`,
+      signature: `0x${(0, import_utils43.bytesToHex)((0, import_utils43.randomBytes)(64))}`,
       // Mock signature
       validUntil: now + 60,
       estimatedGas: 200000n
@@ -29509,7 +29777,7 @@ var MockSolver = class {
         error: status.error
       };
     }
-    const txHash = `0x${(0, import_utils42.bytesToHex)((0, import_utils42.randomBytes)(32))}`;
+    const txHash = `0x${(0, import_utils43.bytesToHex)((0, import_utils43.randomBytes)(32))}`;
     status.status = "completed";
     status.txHash = txHash;
     return {
@@ -29519,10 +29787,10 @@ var MockSolver = class {
       txHash: intent.privacyLevel === "transparent" ? txHash : void 0,
       fulfillmentProof: {
         type: "fulfillment",
-        proof: `0x${(0, import_utils42.bytesToHex)((0, import_utils42.randomBytes)(128))}`,
+        proof: `0x${(0, import_utils43.bytesToHex)((0, import_utils43.randomBytes)(128))}`,
         publicInputs: [
-          `0x${(0, import_utils42.bytesToHex)(new TextEncoder().encode(intent.intentId))}`,
-          `0x${(0, import_utils42.bytesToHex)(new TextEncoder().encode(quote.quoteId))}`
+          `0x${(0, import_utils43.bytesToHex)(new TextEncoder().encode(intent.intentId))}`,
+          `0x${(0, import_utils43.bytesToHex)(new TextEncoder().encode(quote.quoteId))}`
         ]
       },
       fulfilledAt: Math.floor(Date.now() / 1e3)
@@ -30081,6 +30349,7 @@ var SmartRouter = class {
       log4.warn({ backend, error }, "Backend failed");
     });
   }
+  registry;
   cache;
   tracker;
   backendTimeoutMs;
@@ -31087,7 +31356,7 @@ function createZcashNativeBackend(config) {
 var import_types27 = require("@sip-protocol/types");
 init_stealth2();
 init_errors();
-var import_utils43 = require("@noble/hashes/utils");
+var import_utils44 = require("@noble/hashes/utils");
 var DEFAULT_GAS_FEES = {
   ethereum: 21000n * 50n * 1000000000n,
   // 21k gas * 50 gwei = 0.00105 ETH
@@ -31146,6 +31415,8 @@ var ZcashRPCError = class extends Error {
     this.data = data;
     this.name = "ZcashRPCError";
   }
+  code;
+  data;
   /**
    * Check if error is due to insufficient funds
    */
@@ -32423,7 +32694,7 @@ var import_types89 = require("@sip-protocol/types");
 // src/bitcoin/taproot.ts
 var import_secp256k15 = require("@noble/curves/secp256k1");
 var import_sha25615 = require("@noble/hashes/sha256");
-var import_utils45 = require("@noble/hashes/utils");
+var import_utils46 = require("@noble/hashes/utils");
 init_errors();
 init_validation();
 var BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
@@ -32480,16 +32751,16 @@ function computeTweakedKey(internalKey, merkleRoot) {
   }
   const tweakData = merkleRoot ? new Uint8Array([...internalKey, ...merkleRoot]) : internalKey;
   const tweak = taggedHash("TapTweak", tweakData);
-  const tweakScalar = BigInt("0x" + (0, import_utils45.bytesToHex)(tweak)) % import_secp256k15.secp256k1.CURVE.n;
+  const tweakScalar = BigInt("0x" + (0, import_utils46.bytesToHex)(tweak)) % import_secp256k15.secp256k1.CURVE.n;
   const internalPoint = import_secp256k15.secp256k1.ProjectivePoint.fromHex(
-    "02" + (0, import_utils45.bytesToHex)(internalKey)
+    "02" + (0, import_utils46.bytesToHex)(internalKey)
   );
   const tweakPoint = import_secp256k15.secp256k1.ProjectivePoint.BASE.multiply(tweakScalar);
   const tweakedPoint = internalPoint.add(tweakPoint);
   const tweakedKeyBytes = tweakedPoint.toRawBytes(false);
   const xOnly = tweakedKeyBytes.slice(1, 33);
   const yCoord = tweakedKeyBytes.slice(33, 65);
-  const yBigInt = BigInt("0x" + (0, import_utils45.bytesToHex)(yCoord));
+  const yBigInt = BigInt("0x" + (0, import_utils46.bytesToHex)(yCoord));
   const parity = Number(yBigInt & 1n);
   return {
     tweakedKey: xOnly,
@@ -32519,9 +32790,9 @@ function createTaprootOutput(internalKey, scripts) {
   }
   const { tweakedKey, parity } = computeTweakedKey(internalKey, merkleRoot);
   return {
-    tweakedKey: `0x${(0, import_utils45.bytesToHex)(tweakedKey)}`,
-    internalKey: `0x${(0, import_utils45.bytesToHex)(internalKey)}`,
-    merkleRoot: merkleRoot ? `0x${(0, import_utils45.bytesToHex)(merkleRoot)}` : void 0,
+    tweakedKey: `0x${(0, import_utils46.bytesToHex)(tweakedKey)}`,
+    internalKey: `0x${(0, import_utils46.bytesToHex)(internalKey)}`,
+    merkleRoot: merkleRoot ? `0x${(0, import_utils46.bytesToHex)(merkleRoot)}` : void 0,
     parity
   };
 }
@@ -32654,10 +32925,10 @@ function createKeySpendOnlyOutput(privateKey, network = "mainnet") {
   if (!isValidPrivateKey(privateKey)) {
     throw new ValidationError("privateKey must be a valid 32-byte hex string", "privateKey");
   }
-  const privKeyBytes = (0, import_utils45.hexToBytes)(privateKey.slice(2));
+  const privKeyBytes = (0, import_utils46.hexToBytes)(privateKey.slice(2));
   const internalKey = getXOnlyPublicKey(privKeyBytes);
   const output = createTaprootOutput(internalKey);
-  const tweakedKeyBytes = (0, import_utils45.hexToBytes)(output.tweakedKey.slice(2));
+  const tweakedKeyBytes = (0, import_utils46.hexToBytes)(output.tweakedKey.slice(2));
   const address = taprootAddress(tweakedKeyBytes, network);
   return {
     output,
@@ -32683,11 +32954,11 @@ function schnorrSignHex(message, privateKey, auxRand) {
   if (auxRand && !isValidHex(auxRand)) {
     throw new ValidationError("auxRand must be a hex string", "auxRand");
   }
-  const messageBytes = (0, import_utils45.hexToBytes)(message.slice(2));
-  const privateKeyBytes = (0, import_utils45.hexToBytes)(privateKey.slice(2));
-  const auxRandBytes = auxRand ? (0, import_utils45.hexToBytes)(auxRand.slice(2)) : void 0;
+  const messageBytes = (0, import_utils46.hexToBytes)(message.slice(2));
+  const privateKeyBytes = (0, import_utils46.hexToBytes)(privateKey.slice(2));
+  const auxRandBytes = auxRand ? (0, import_utils46.hexToBytes)(auxRand.slice(2)) : void 0;
   const signature = schnorrSign(messageBytes, privateKeyBytes, auxRandBytes);
-  return `0x${(0, import_utils45.bytesToHex)(signature)}`;
+  return `0x${(0, import_utils46.bytesToHex)(signature)}`;
 }
 function schnorrVerifyHex(signature, message, publicKey) {
   if (!isValidHex(signature)) {
@@ -32699,23 +32970,23 @@ function schnorrVerifyHex(signature, message, publicKey) {
   if (!isValidHex(publicKey)) {
     throw new ValidationError("publicKey must be a hex string", "publicKey");
   }
-  const signatureBytes = (0, import_utils45.hexToBytes)(signature.slice(2));
-  const messageBytes = (0, import_utils45.hexToBytes)(message.slice(2));
-  const publicKeyBytes = (0, import_utils45.hexToBytes)(publicKey.slice(2));
+  const signatureBytes = (0, import_utils46.hexToBytes)(signature.slice(2));
+  const messageBytes = (0, import_utils46.hexToBytes)(message.slice(2));
+  const publicKeyBytes = (0, import_utils46.hexToBytes)(publicKey.slice(2));
   return schnorrVerify(signatureBytes, messageBytes, publicKeyBytes);
 }
 
 // src/bitcoin/silent-payments.ts
 var import_secp256k16 = require("@noble/curves/secp256k1");
 var import_sha25616 = require("@noble/hashes/sha256");
-var import_utils46 = require("@noble/hashes/utils");
+var import_utils47 = require("@noble/hashes/utils");
 init_errors();
 init_validation();
 
 // src/payment/payment.ts
 var import_types32 = require("@sip-protocol/types");
 var import_sha25617 = require("@noble/hashes/sha256");
-var import_utils47 = require("@noble/hashes/utils");
+var import_utils48 = require("@noble/hashes/utils");
 var import_chacha3 = require("@noble/ciphers/chacha.js");
 var import_hkdf3 = require("@noble/hashes/hkdf");
 init_stealth2();
@@ -33215,8 +33486,8 @@ async function createShieldedPayment(params, options) {
   let viewingKeyHash;
   if (viewingKey) {
     const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-    const keyBytes = (0, import_utils47.hexToBytes)(keyHex);
-    viewingKeyHash = `0x${(0, import_utils47.bytesToHex)((0, import_sha25617.sha256)(keyBytes))}`;
+    const keyBytes = (0, import_utils48.hexToBytes)(keyHex);
+    viewingKeyHash = `0x${(0, import_utils48.bytesToHex)((0, import_sha25617.sha256)(keyBytes))}`;
   }
   const privacyConfig = getPrivacyConfig(
     privacy,
@@ -33256,7 +33527,7 @@ async function createShieldedPayment(params, options) {
   if (privacy !== import_types32.PrivacyLevel.TRANSPARENT && proofProvider?.isReady) {
     const hexToUint8 = (hex) => {
       const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-      return (0, import_utils47.hexToBytes)(cleanHex);
+      return (0, import_utils48.hexToBytes)(cleanHex);
     };
     const fundingResult = await proofProvider.generateFundingProof({
       balance: amount,
@@ -33283,17 +33554,17 @@ async function createShieldedPayment(params, options) {
 }
 function encryptMemo(memo, viewingKey) {
   const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-  const keyBytes = (0, import_utils47.hexToBytes)(keyHex);
+  const keyBytes = (0, import_utils48.hexToBytes)(keyHex);
   const encKey = (0, import_hkdf3.hkdf)(import_sha25617.sha256, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
   try {
-    const nonce = (0, import_utils47.randomBytes)(24);
+    const nonce = (0, import_utils48.randomBytes)(24);
     const cipher = (0, import_chacha3.xchacha20poly1305)(encKey, nonce);
     const plaintext = new TextEncoder().encode(memo);
     const ciphertext = cipher.encrypt(plaintext);
     const result = new Uint8Array(nonce.length + ciphertext.length);
     result.set(nonce);
     result.set(ciphertext, nonce.length);
-    return `0x${(0, import_utils47.bytesToHex)(result)}`;
+    return `0x${(0, import_utils48.bytesToHex)(result)}`;
   } finally {
     secureWipe(keyBytes);
     secureWipe(encKey);
@@ -33301,11 +33572,11 @@ function encryptMemo(memo, viewingKey) {
 }
 function decryptMemo(encryptedMemo, viewingKey) {
   const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-  const keyBytes = (0, import_utils47.hexToBytes)(keyHex);
+  const keyBytes = (0, import_utils48.hexToBytes)(keyHex);
   const encKey = (0, import_hkdf3.hkdf)(import_sha25617.sha256, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
   try {
     const dataHex = encryptedMemo.startsWith("0x") ? encryptedMemo.slice(2) : encryptedMemo;
-    const data = (0, import_utils47.hexToBytes)(dataHex);
+    const data = (0, import_utils48.hexToBytes)(dataHex);
     const nonce = data.slice(0, 24);
     const ciphertext = data.slice(24);
     const cipher = (0, import_chacha3.xchacha20poly1305)(encKey, nonce);
@@ -33355,7 +33626,7 @@ function getPaymentSummary(payment) {
 var import_types33 = require("@sip-protocol/types");
 var import_secp256k17 = require("@noble/curves/secp256k1");
 var import_sha25618 = require("@noble/hashes/sha256");
-var import_utils48 = require("@noble/hashes/utils");
+var import_utils49 = require("@noble/hashes/utils");
 init_errors();
 init_validation();
 init_secure_memory();
@@ -33849,12 +34120,12 @@ var Treasury = class _Treasury {
   }
 };
 function generateTreasuryId() {
-  const bytes = (0, import_utils48.randomBytes)(16);
-  return `treasury_${(0, import_utils48.bytesToHex)(bytes)}`;
+  const bytes = (0, import_utils49.randomBytes)(16);
+  return `treasury_${(0, import_utils49.bytesToHex)(bytes)}`;
 }
 function generateProposalId() {
-  const bytes = (0, import_utils48.randomBytes)(16);
-  return `prop_${(0, import_utils48.bytesToHex)(bytes)}`;
+  const bytes = (0, import_utils49.randomBytes)(16);
+  return `prop_${(0, import_utils49.bytesToHex)(bytes)}`;
 }
 function computeProposalHash(proposal) {
   const data = JSON.stringify({
@@ -33870,7 +34141,7 @@ function computeProposalHash(proposal) {
 }
 function signMessage(messageHash, privateKey) {
   const keyHex = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
-  const keyBytes = (0, import_utils48.hexToBytes)(keyHex);
+  const keyBytes = (0, import_utils49.hexToBytes)(keyHex);
   try {
     const signature = import_secp256k17.secp256k1.sign(messageHash, keyBytes);
     return `0x${signature.toCompactHex()}`;
@@ -33882,8 +34153,8 @@ function verifySignature(messageHash, signature, publicKey) {
   const sigHex = signature.startsWith("0x") ? signature.slice(2) : signature;
   const pubKeyHex = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
   try {
-    const sigBytes = (0, import_utils48.hexToBytes)(sigHex);
-    const pubKeyBytes = (0, import_utils48.hexToBytes)(pubKeyHex);
+    const sigBytes = (0, import_utils49.hexToBytes)(sigHex);
+    const pubKeyBytes = (0, import_utils49.hexToBytes)(pubKeyHex);
     return import_secp256k17.secp256k1.verify(sigBytes, messageHash, pubKeyBytes);
   } catch {
     return false;
@@ -34042,7 +34313,7 @@ function validateBatchProposalParams(params, config) {
 
 // src/compliance/compliance-manager.ts
 var import_types34 = require("@sip-protocol/types");
-var import_utils49 = require("@noble/hashes/utils");
+var import_utils50 = require("@noble/hashes/utils");
 init_errors();
 var DEFAULTS2 = {
   riskThreshold: 70,
@@ -34790,7 +35061,7 @@ var ComplianceManager = class _ComplianceManager {
   }
 };
 function generateId5(prefix) {
-  return `${prefix}_${(0, import_utils49.bytesToHex)((0, import_utils49.randomBytes)(12))}`;
+  return `${prefix}_${(0, import_utils50.bytesToHex)((0, import_utils50.randomBytes)(12))}`;
 }
 function validateRegisterAuditorParams(params) {
   if (!params.organization?.trim()) {
@@ -34879,7 +35150,7 @@ function validateReportParams(params) {
 
 // src/compliance/reports.ts
 var import_sha25619 = require("@noble/hashes/sha256");
-var import_utils50 = require("@noble/hashes/utils");
+var import_utils51 = require("@noble/hashes/utils");
 init_errors();
 
 // src/compliance/pdf.ts
@@ -35181,12 +35452,12 @@ var ComplianceReporter = class {
   normalizeViewingKey(viewingKey) {
     if (typeof viewingKey === "string") {
       const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-      const keyBytes = (0, import_utils50.hexToBytes)(keyHex);
+      const keyBytes = (0, import_utils51.hexToBytes)(keyHex);
       const hashBytes = (0, import_sha25619.sha256)(keyBytes);
       return {
         key: `0x${keyHex}`,
         path: "m/0",
-        hash: `0x${(0, import_utils50.bytesToHex)(hashBytes)}`
+        hash: `0x${(0, import_utils51.bytesToHex)(hashBytes)}`
       };
     }
     return viewingKey;
@@ -35568,7 +35839,7 @@ var ComplianceReporter = class {
 
 // src/compliance/conditional.ts
 var import_sha25620 = require("@noble/hashes/sha256");
-var import_utils51 = require("@noble/hashes/utils");
+var import_utils52 = require("@noble/hashes/utils");
 var import_chacha4 = require("@noble/ciphers/chacha.js");
 init_errors();
 var ConditionalDisclosure = class {
@@ -35635,8 +35906,8 @@ var ConditionalDisclosure = class {
         params.commitment,
         revealAfterSeconds
       );
-      const nonce = (0, import_utils51.randomBytes)(24);
-      const viewingKeyBytes = (0, import_utils51.hexToBytes)(params.viewingKey.slice(2));
+      const nonce = (0, import_utils52.randomBytes)(24);
+      const viewingKeyBytes = (0, import_utils52.hexToBytes)(params.viewingKey.slice(2));
       const cipher = (0, import_chacha4.xchacha20poly1305)(encryptionKey, nonce);
       const encryptedKey = cipher.encrypt(viewingKeyBytes);
       const commitmentData = new Uint8Array([
@@ -35645,10 +35916,10 @@ var ConditionalDisclosure = class {
       ]);
       const commitmentHash = (0, import_sha25620.sha256)(commitmentData);
       return {
-        encryptedKey: "0x" + (0, import_utils51.bytesToHex)(encryptedKey),
-        nonce: "0x" + (0, import_utils51.bytesToHex)(nonce),
+        encryptedKey: "0x" + (0, import_utils52.bytesToHex)(encryptedKey),
+        nonce: "0x" + (0, import_utils52.bytesToHex)(nonce),
         revealAfter: revealAfterSeconds,
-        verificationCommitment: "0x" + (0, import_utils51.bytesToHex)(commitmentHash),
+        verificationCommitment: "0x" + (0, import_utils52.bytesToHex)(commitmentHash),
         encryptionCommitment: params.commitment,
         type
       };
@@ -35725,11 +35996,11 @@ var ConditionalDisclosure = class {
         timeLock.encryptionCommitment,
         timeLock.revealAfter
       );
-      const nonce = (0, import_utils51.hexToBytes)(timeLock.nonce.slice(2));
-      const encryptedData = (0, import_utils51.hexToBytes)(timeLock.encryptedKey.slice(2));
+      const nonce = (0, import_utils52.hexToBytes)(timeLock.nonce.slice(2));
+      const encryptedData = (0, import_utils52.hexToBytes)(timeLock.encryptedKey.slice(2));
       const cipher = (0, import_chacha4.xchacha20poly1305)(encryptionKey, nonce);
       const decryptedBytes = cipher.decrypt(encryptedData);
-      const viewingKey = "0x" + (0, import_utils51.bytesToHex)(decryptedBytes);
+      const viewingKey = "0x" + (0, import_utils52.bytesToHex)(decryptedBytes);
       return {
         unlocked: true,
         viewingKey
@@ -35760,13 +36031,13 @@ var ConditionalDisclosure = class {
    */
   verifyCommitment(timeLock, viewingKey) {
     try {
-      const viewingKeyBytes = (0, import_utils51.hexToBytes)(viewingKey.slice(2));
+      const viewingKeyBytes = (0, import_utils52.hexToBytes)(viewingKey.slice(2));
       const commitmentData = new Uint8Array([
         ...viewingKeyBytes,
         ...this._numberToBytes(timeLock.revealAfter)
       ]);
       const expectedCommitment = (0, import_sha25620.sha256)(commitmentData);
-      const actualCommitment = (0, import_utils51.hexToBytes)(timeLock.verificationCommitment.slice(2));
+      const actualCommitment = (0, import_utils52.hexToBytes)(timeLock.verificationCommitment.slice(2));
       if (expectedCommitment.length !== actualCommitment.length) {
         return false;
       }
@@ -35785,7 +36056,7 @@ var ConditionalDisclosure = class {
    * @private
    */
   _deriveEncryptionKey(commitment, revealAfter) {
-    const commitmentBytes = (0, import_utils51.hexToBytes)(commitment.slice(2));
+    const commitmentBytes = (0, import_utils52.hexToBytes)(commitment.slice(2));
     const timeBytes = this._numberToBytes(revealAfter);
     const combined = new Uint8Array([...commitmentBytes, ...timeBytes]);
     const key = (0, import_sha25620.sha256)(combined);
@@ -35817,14 +36088,14 @@ var ConditionalDisclosure = class {
 // src/compliance/conditional-threshold.ts
 var import_secp256k18 = require("@noble/curves/secp256k1");
 var import_sha25621 = require("@noble/hashes/sha256");
-var import_utils52 = require("@noble/hashes/utils");
+var import_utils53 = require("@noble/hashes/utils");
 init_commitment();
 init_errors();
 var CURVE_ORDER2 = import_secp256k18.secp256k1.CURVE.n;
 
 // src/compliance/threshold.ts
 var import_sha25622 = require("@noble/hashes/sha256");
-var import_utils53 = require("@noble/hashes/utils");
+var import_utils54 = require("@noble/hashes/utils");
 init_errors();
 var FIELD_PRIME = 2n ** 256n - 189n;
 var ThresholdViewingKey = class {
@@ -36008,7 +36279,7 @@ var ThresholdViewingKey = class {
    * Convert viewing key to secret (bigint)
    */
   static viewingKeyToSecret(viewingKey) {
-    const bytes = (0, import_utils53.hexToBytes)(viewingKey.slice(2));
+    const bytes = (0, import_utils54.hexToBytes)(viewingKey.slice(2));
     let secret = 0n;
     for (let i = 0; i < bytes.length; i++) {
       secret = secret << 8n | BigInt(bytes[i]);
@@ -36042,7 +36313,7 @@ var ThresholdViewingKey = class {
    * Generate a random field element
    */
   static randomFieldElement() {
-    const bytes = (0, import_utils53.randomBytes)(32);
+    const bytes = (0, import_utils54.randomBytes)(32);
     let value = 0n;
     for (let i = 0; i < bytes.length; i++) {
       value = value << 8n | BigInt(bytes[i]);
@@ -36067,8 +36338,8 @@ var ThresholdViewingKey = class {
    */
   static createCommitment(secret, coefficients) {
     const data = [secret, ...coefficients].map((c) => c.toString(16).padStart(64, "0")).join("");
-    const hash2 = (0, import_sha25622.sha256)((0, import_utils53.hexToBytes)(data));
-    return (0, import_utils53.bytesToHex)(hash2);
+    const hash2 = (0, import_sha25622.sha256)((0, import_utils54.hexToBytes)(data));
+    return (0, import_utils54.bytesToHex)(hash2);
   }
   /**
    * Encode share as string: "x:y:len:commitment"
@@ -36192,9 +36463,9 @@ var ThresholdViewingKey = class {
 
 // src/compliance/derivation.ts
 var import_sha25623 = require("@noble/hashes/sha256");
-var import_sha5123 = require("@noble/hashes/sha512");
+var import_sha5124 = require("@noble/hashes/sha512");
 var import_hmac5 = require("@noble/hashes/hmac");
-var import_utils54 = require("@noble/hashes/utils");
+var import_utils55 = require("@noble/hashes/utils");
 init_errors();
 init_secure_memory();
 var AuditorType = /* @__PURE__ */ ((AuditorType2) => {
@@ -36293,7 +36564,7 @@ var AuditorKeyDerivation = class {
       auditorType
       // auditorType (non-hardened)
     ];
-    const masterData = (0, import_hmac5.hmac)(import_sha5123.sha512, (0, import_utils54.utf8ToBytes)("SIP-MASTER-SEED"), masterSeed);
+    const masterData = (0, import_hmac5.hmac)(import_sha5124.sha512, (0, import_utils55.utf8ToBytes)("SIP-MASTER-SEED"), masterSeed);
     let currentKey = new Uint8Array(masterData.slice(0, 32));
     let chainCode = new Uint8Array(masterData.slice(32, 64));
     try {
@@ -36306,9 +36577,9 @@ var AuditorKeyDerivation = class {
         currentKey = new Uint8Array(derived.key);
         chainCode = new Uint8Array(derived.chainCode);
       }
-      const keyHex = `0x${(0, import_utils54.bytesToHex)(currentKey)}`;
+      const keyHex = `0x${(0, import_utils55.bytesToHex)(currentKey)}`;
       const hashBytes = (0, import_sha25623.sha256)(currentKey);
-      const hash2 = `0x${(0, import_utils54.bytesToHex)(hashBytes)}`;
+      const hash2 = `0x${(0, import_utils55.bytesToHex)(hashBytes)}`;
       const viewingKey = {
         key: keyHex,
         path,
@@ -36375,7 +36646,7 @@ var AuditorKeyDerivation = class {
       account | this.HARDENED
       // account' (hardened)
     ];
-    const masterData = (0, import_hmac5.hmac)(import_sha5123.sha512, (0, import_utils54.utf8ToBytes)("SIP-MASTER-SEED"), masterSeed);
+    const masterData = (0, import_hmac5.hmac)(import_sha5124.sha512, (0, import_utils55.utf8ToBytes)("SIP-MASTER-SEED"), masterSeed);
     let commonKey = new Uint8Array(masterData.slice(0, 32));
     let commonChainCode = new Uint8Array(masterData.slice(32, 64));
     try {
@@ -36392,9 +36663,9 @@ var AuditorKeyDerivation = class {
       for (const auditorType of uniqueTypes) {
         const derived = this.deriveChildKey(commonKey, commonChainCode, auditorType);
         try {
-          const keyHex = `0x${(0, import_utils54.bytesToHex)(derived.key)}`;
+          const keyHex = `0x${(0, import_utils55.bytesToHex)(derived.key)}`;
           const hashBytes = (0, import_sha25623.sha256)(derived.key);
-          const hash2 = `0x${(0, import_utils54.bytesToHex)(hashBytes)}`;
+          const hash2 = `0x${(0, import_utils55.bytesToHex)(hashBytes)}`;
           const path = this.derivePath(auditorType, account);
           const viewingKey = {
             key: keyHex,
@@ -36459,7 +36730,7 @@ var AuditorKeyDerivation = class {
     }
     const indexView = new DataView(data.buffer, 33, 4);
     indexView.setUint32(0, index, false);
-    const hmacResult = (0, import_hmac5.hmac)(import_sha5123.sha512, chainCode, data);
+    const hmacResult = (0, import_hmac5.hmac)(import_sha5124.sha512, chainCode, data);
     const childKey = new Uint8Array(hmacResult.slice(0, 32));
     const childChainCode = new Uint8Array(hmacResult.slice(32, 64));
     return {
@@ -36517,8 +36788,8 @@ var AuditorKeyDerivation = class {
 // src/compliance/range-sas.ts
 var import_sha25624 = require("@noble/hashes/sha256");
 var import_hmac6 = require("@noble/hashes/hmac");
-var import_sha5124 = require("@noble/hashes/sha512");
-var import_utils55 = require("@noble/hashes/utils");
+var import_sha5125 = require("@noble/hashes/sha512");
+var import_utils56 = require("@noble/hashes/utils");
 init_errors();
 init_secure_memory();
 var AttestationSchema = /* @__PURE__ */ ((AttestationSchema2) => {
@@ -36754,16 +37025,16 @@ var AttestationGatedDisclosure = class {
    */
   deriveKeyFromAttestation(attestation) {
     const masterKeyHex = this.config.masterViewingKey.key.startsWith("0x") ? this.config.masterViewingKey.key.slice(2) : this.config.masterViewingKey.key;
-    const masterKeyBytes = (0, import_utils55.hexToBytes)(masterKeyHex);
-    const derivationData = (0, import_utils55.utf8ToBytes)(
+    const masterKeyBytes = (0, import_utils56.hexToBytes)(masterKeyHex);
+    const derivationData = (0, import_utils56.utf8ToBytes)(
       `SIP-RANGE-SAS:${attestation.uid}:${attestation.subject}:${attestation.schema}:${attestation.signature}`
     );
-    const derived = (0, import_hmac6.hmac)(import_sha5124.sha512, masterKeyBytes, derivationData);
+    const derived = (0, import_hmac6.hmac)(import_sha5125.sha512, masterKeyBytes, derivationData);
     const keyBytes = derived.slice(0, 32);
     try {
-      const key = `0x${(0, import_utils55.bytesToHex)(keyBytes)}`;
+      const key = `0x${(0, import_utils56.bytesToHex)(keyBytes)}`;
       const hashBytes = (0, import_sha25624.sha256)(keyBytes);
-      const hash2 = `0x${(0, import_utils55.bytesToHex)(hashBytes)}`;
+      const hash2 = `0x${(0, import_utils56.bytesToHex)(hashBytes)}`;
       return {
         key,
         path: `${this.config.masterViewingKey.path}/sas/${attestation.uid.slice(0, 8)}`,
@@ -36855,13 +37126,13 @@ async function verifyAttestationSignature(attestation, options = {}) {
   const signedMessage = constructAttestationMessage(attestation);
   try {
     const { ed25519: ed2551918 } = await import("@noble/curves/ed25519");
-    const signatureBytes = (0, import_utils55.hexToBytes)(
+    const signatureBytes = (0, import_utils56.hexToBytes)(
       attestation.signature.startsWith("0x") ? attestation.signature.slice(2) : attestation.signature
     );
-    const publicKeyBytes = (0, import_utils55.hexToBytes)(
+    const publicKeyBytes = (0, import_utils56.hexToBytes)(
       issuerPublicKey.startsWith("0x") ? issuerPublicKey.slice(2) : issuerPublicKey
     );
-    const messageBytes = (0, import_utils55.utf8ToBytes)(signedMessage);
+    const messageBytes = (0, import_utils56.utf8ToBytes)(signedMessage);
     return ed2551918.verify(signatureBytes, messageBytes, publicKeyBytes);
   } catch (error) {
     console.warn(`[Range SAS] Signature verification error: ${error}`);
@@ -37018,11 +37289,11 @@ async function fetchWalletAttestations(walletAddress, options = {}) {
 
 // src/compliance/fireblocks.ts
 var import_sha25625 = require("@noble/hashes/sha256");
-var import_utils56 = require("@noble/hashes/utils");
+var import_utils57 = require("@noble/hashes/utils");
 
 // src/auction/sealed-bid.ts
 init_commitment();
-var import_utils57 = require("@noble/hashes/utils");
+var import_utils58 = require("@noble/hashes/utils");
 init_errors();
 var SealedBidAuction = class {
   /**
@@ -37100,7 +37371,7 @@ var SealedBidAuction = class {
         );
       }
     }
-    const salt = params.salt ?? (0, import_utils57.randomBytes)(32);
+    const salt = params.salt ?? (0, import_utils58.randomBytes)(32);
     const { commitment, blinding } = commit(params.amount, salt);
     const sealedBid = {
       auctionId: params.auctionId,
@@ -37244,7 +37515,7 @@ var SealedBidAuction = class {
    * ```
    */
   revealBid(bid, amount, salt) {
-    const saltHex = `0x${(0, import_utils57.bytesToHex)(salt)}`;
+    const saltHex = `0x${(0, import_utils58.bytesToHex)(salt)}`;
     const isValid = this.verifyBid({
       commitment: bid.commitment,
       amount,
@@ -37731,7 +38002,7 @@ function createSealedBidAuction() {
 // src/governance/private-vote.ts
 var import_sha25626 = require("@noble/hashes/sha256");
 var import_hkdf4 = require("@noble/hashes/hkdf");
-var import_utils58 = require("@noble/hashes/utils");
+var import_utils59 = require("@noble/hashes/utils");
 var import_chacha5 = require("@noble/ciphers/chacha.js");
 init_errors();
 init_secure_memory();
@@ -37772,7 +38043,7 @@ var PrivateVoting = class {
     const { proposalId, choice, weight, encryptionKey, voter = "anonymous" } = params;
     const derivedKey = this.deriveEncryptionKey(encryptionKey, proposalId);
     try {
-      const nonce = (0, import_utils58.randomBytes)(NONCE_SIZE3);
+      const nonce = (0, import_utils59.randomBytes)(NONCE_SIZE3);
       const voteData = {
         proposalId,
         choice,
@@ -37780,14 +38051,14 @@ var PrivateVoting = class {
         voter,
         timestamp: Date.now()
       };
-      const plaintext = (0, import_utils58.utf8ToBytes)(JSON.stringify(voteData));
+      const plaintext = (0, import_utils59.utf8ToBytes)(JSON.stringify(voteData));
       const cipher = (0, import_chacha5.xchacha20poly1305)(derivedKey, nonce);
       const ciphertext = cipher.encrypt(plaintext);
-      const keyHash = (0, import_sha25626.sha256)((0, import_utils58.hexToBytes)(encryptionKey.slice(2)));
+      const keyHash = (0, import_sha25626.sha256)((0, import_utils59.hexToBytes)(encryptionKey.slice(2)));
       return {
-        ciphertext: `0x${(0, import_utils58.bytesToHex)(ciphertext)}`,
-        nonce: `0x${(0, import_utils58.bytesToHex)(nonce)}`,
-        encryptionKeyHash: `0x${(0, import_utils58.bytesToHex)(keyHash)}`,
+        ciphertext: `0x${(0, import_utils59.bytesToHex)(ciphertext)}`,
+        nonce: `0x${(0, import_utils59.bytesToHex)(nonce)}`,
+        encryptionKeyHash: `0x${(0, import_utils59.bytesToHex)(keyHash)}`,
         proposalId,
         voter,
         timestamp: voteData.timestamp
@@ -37833,8 +38104,8 @@ var PrivateVoting = class {
     }
     const derivedKey = this.deriveEncryptionKey(decryptionKey, vote.proposalId);
     try {
-      const keyHash = (0, import_sha25626.sha256)((0, import_utils58.hexToBytes)(decryptionKey.slice(2)));
-      const expectedKeyHash = `0x${(0, import_utils58.bytesToHex)(keyHash)}`;
+      const keyHash = (0, import_sha25626.sha256)((0, import_utils59.hexToBytes)(decryptionKey.slice(2)));
+      const expectedKeyHash = `0x${(0, import_utils59.bytesToHex)(keyHash)}`;
       if (vote.encryptionKeyHash !== expectedKeyHash) {
         throw new CryptoError(
           "Decryption key hash mismatch - this key cannot decrypt this vote",
@@ -37843,9 +38114,9 @@ var PrivateVoting = class {
         );
       }
       const nonceHex = vote.nonce.startsWith("0x") ? vote.nonce.slice(2) : vote.nonce;
-      const nonce = (0, import_utils58.hexToBytes)(nonceHex);
+      const nonce = (0, import_utils59.hexToBytes)(nonceHex);
       const ciphertextHex = vote.ciphertext.startsWith("0x") ? vote.ciphertext.slice(2) : vote.ciphertext;
-      const ciphertext = (0, import_utils58.hexToBytes)(ciphertextHex);
+      const ciphertext = (0, import_utils59.hexToBytes)(ciphertextHex);
       const cipher = (0, import_chacha5.xchacha20poly1305)(derivedKey, nonce);
       let plaintext;
       try {
@@ -37934,10 +38205,10 @@ var PrivateVoting = class {
    */
   deriveEncryptionKey(key, proposalId) {
     const keyHex = key.startsWith("0x") ? key.slice(2) : key;
-    const keyBytes = (0, import_utils58.hexToBytes)(keyHex);
+    const keyBytes = (0, import_utils59.hexToBytes)(keyHex);
     try {
-      const salt = (0, import_utils58.utf8ToBytes)(VOTE_ENCRYPTION_DOMAIN);
-      const info = (0, import_utils58.utf8ToBytes)(proposalId);
+      const salt = (0, import_utils59.utf8ToBytes)(VOTE_ENCRYPTION_DOMAIN);
+      const info = (0, import_utils59.utf8ToBytes)(proposalId);
       return (0, import_hkdf4.hkdf)(import_sha25626.sha256, keyBytes, salt, info, 32);
     } finally {
       secureWipe(keyBytes);
@@ -38083,21 +38354,21 @@ var PrivateVoting = class {
     const blindings = {};
     for (const [choice, weights] of Object.entries(votesByChoice)) {
       const totalWeight = weights.reduce((sum, w) => sum + w, 0n);
-      const { commitment, blinding } = commit(totalWeight, (0, import_utils58.hexToBytes)(generateBlinding().slice(2)));
+      const { commitment, blinding } = commit(totalWeight, (0, import_utils59.hexToBytes)(generateBlinding().slice(2)));
       tallies[choice] = commitment;
       blindings[choice] = blinding;
     }
     const encryptedBlindings = {};
     for (const [choice, blinding] of Object.entries(blindings)) {
-      const nonce = (0, import_utils58.randomBytes)(NONCE_SIZE3);
+      const nonce = (0, import_utils59.randomBytes)(NONCE_SIZE3);
       const derivedKey = this.deriveEncryptionKey(decryptionKey, `${proposalId}-tally-${choice}`);
       try {
         const cipher = (0, import_chacha5.xchacha20poly1305)(derivedKey, nonce);
-        const blindingBytes = (0, import_utils58.hexToBytes)(blinding.slice(2));
+        const blindingBytes = (0, import_utils59.hexToBytes)(blinding.slice(2));
         const ciphertext = cipher.encrypt(blindingBytes);
         encryptedBlindings[choice] = {
-          ciphertext: `0x${(0, import_utils58.bytesToHex)(ciphertext)}`,
-          nonce: `0x${(0, import_utils58.bytesToHex)(nonce)}`
+          ciphertext: `0x${(0, import_utils59.bytesToHex)(ciphertext)}`,
+          nonce: `0x${(0, import_utils59.bytesToHex)(nonce)}`
         };
       } finally {
         secureWipe(derivedKey);
@@ -38190,9 +38461,9 @@ var PrivateVoting = class {
     }
     let reconstructedKey = null;
     try {
-      reconstructedKey = (0, import_utils58.hexToBytes)(decryptionShares[0].share.slice(2));
+      reconstructedKey = (0, import_utils59.hexToBytes)(decryptionShares[0].share.slice(2));
       for (let i = 1; i < decryptionShares.length; i++) {
-        const shareBytes = (0, import_utils58.hexToBytes)(decryptionShares[i].share.slice(2));
+        const shareBytes = (0, import_utils59.hexToBytes)(decryptionShares[i].share.slice(2));
         if (shareBytes.length !== reconstructedKey.length) {
           throw new ValidationError(
             "all decryption shares must have the same length",
@@ -38205,7 +38476,7 @@ var PrivateVoting = class {
           reconstructedKey[j] ^= shareBytes[j];
         }
       }
-      const reconstructedKeyHex = `0x${(0, import_utils58.bytesToHex)(reconstructedKey)}`;
+      const reconstructedKeyHex = `0x${(0, import_utils59.bytesToHex)(reconstructedKey)}`;
       const results = {};
       for (const [choice, commitmentPoint] of Object.entries(tally.tallies)) {
         const encBlinding = tally.encryptedBlindings[choice];
@@ -38222,11 +38493,11 @@ var PrivateVoting = class {
         );
         let blindingFactor;
         try {
-          const nonceBytes = (0, import_utils58.hexToBytes)(encBlinding.nonce.slice(2));
-          const ciphertextBytes = (0, import_utils58.hexToBytes)(encBlinding.ciphertext.slice(2));
+          const nonceBytes = (0, import_utils59.hexToBytes)(encBlinding.nonce.slice(2));
+          const ciphertextBytes = (0, import_utils59.hexToBytes)(encBlinding.ciphertext.slice(2));
           const cipher = (0, import_chacha5.xchacha20poly1305)(derivedKey, nonceBytes);
           const blindingBytes = cipher.decrypt(ciphertextBytes);
-          blindingFactor = `0x${(0, import_utils58.bytesToHex)(blindingBytes)}`;
+          blindingFactor = `0x${(0, import_utils59.bytesToHex)(blindingBytes)}`;
         } catch (e) {
           throw new CryptoError(
             "failed to decrypt blinding factor",
@@ -38246,7 +38517,7 @@ var PrivateVoting = class {
           try {
             const { commitment: testCommit } = commit(
               value,
-              (0, import_utils58.hexToBytes)(blindingFactor.slice(2))
+              (0, import_utils59.hexToBytes)(blindingFactor.slice(2))
             );
             if (testCommit === commitmentPoint) {
               results[choice] = value;
@@ -38449,7 +38720,7 @@ function createPrivateVoting() {
 var import_sha25627 = require("@noble/hashes/sha256");
 var import_ed2551910 = require("@noble/curves/ed25519");
 var import_secp256k19 = require("@noble/curves/secp256k1");
-var import_utils59 = require("@noble/hashes/utils");
+var import_utils60 = require("@noble/hashes/utils");
 init_stealth2();
 init_errors();
 init_validation();
@@ -38539,22 +38810,22 @@ var PrivateNFT = class {
     try {
       const message = this.createProofMessage(ownership, challenge);
       const messageHash = (0, import_sha25627.sha256)(new TextEncoder().encode(message));
-      const privateKeyBytes = (0, import_utils59.hexToBytes)(stealthPrivateKey.slice(2));
+      const privateKeyBytes = (0, import_utils60.hexToBytes)(stealthPrivateKey.slice(2));
       const signature = import_secp256k19.secp256k1.sign(messageHash, privateKeyBytes);
       const zkProof = {
         type: "ownership",
-        proof: `0x${(0, import_utils59.bytesToHex)(signature.toCompactRawBytes())}`,
+        proof: `0x${(0, import_utils60.bytesToHex)(signature.toCompactRawBytes())}`,
         publicInputs: [
-          `0x${(0, import_utils59.bytesToHex)(messageHash)}`
+          `0x${(0, import_utils60.bytesToHex)(messageHash)}`
         ]
       };
-      const stealthHashBytes = (0, import_sha25627.sha256)((0, import_utils59.hexToBytes)(ownership.ownerStealth.address.slice(2)));
+      const stealthHashBytes = (0, import_sha25627.sha256)((0, import_utils60.hexToBytes)(ownership.ownerStealth.address.slice(2)));
       return {
         nftContract: ownership.nftContract,
         tokenId: ownership.tokenId,
         challenge,
         proof: zkProof,
-        stealthHash: `0x${(0, import_utils59.bytesToHex)(stealthHashBytes)}`,
+        stealthHash: `0x${(0, import_utils60.bytesToHex)(stealthHashBytes)}`,
         timestamp: Date.now()
       };
     } catch (e) {
@@ -38596,9 +38867,9 @@ var PrivateNFT = class {
   verifyOwnership(proof) {
     try {
       this.validateOwnershipProof(proof);
-      const signatureBytes = (0, import_utils59.hexToBytes)(proof.proof.proof.slice(2));
+      const signatureBytes = (0, import_utils60.hexToBytes)(proof.proof.proof.slice(2));
       const signature = import_secp256k19.secp256k1.Signature.fromCompact(signatureBytes);
-      const messageHash = (0, import_utils59.hexToBytes)(proof.proof.publicInputs[0].slice(2));
+      const messageHash = (0, import_utils60.hexToBytes)(proof.proof.publicInputs[0].slice(2));
       if (signatureBytes.length !== 64) {
         return {
           valid: false,
@@ -38695,12 +38966,12 @@ var PrivateNFT = class {
       chain: nft.chain,
       timestamp: Date.now()
     };
-    const previousOwnerHashBytes = (0, import_sha25627.sha256)((0, import_utils59.hexToBytes)(nft.ownerStealth.address.slice(2)));
+    const previousOwnerHashBytes = (0, import_sha25627.sha256)((0, import_utils60.hexToBytes)(nft.ownerStealth.address.slice(2)));
     const transfer = {
       nftContract: nft.nftContract,
       tokenId: nft.tokenId,
       newOwnerStealth,
-      previousOwnerHash: `0x${(0, import_utils59.bytesToHex)(previousOwnerHashBytes)}`,
+      previousOwnerHash: `0x${(0, import_utils60.bytesToHex)(previousOwnerHashBytes)}`,
       chain: nft.chain,
       timestamp: Date.now()
     };
@@ -38767,9 +39038,9 @@ var PrivateNFT = class {
       );
     }
     const ownedNFTs = [];
-    const viewingKeyHex = `0x${(0, import_utils59.bytesToHex)(viewingKey)}`;
-    const ed25519SpendingPubHex = `0x${(0, import_utils59.bytesToHex)(import_ed2551910.ed25519.getPublicKey(scanKey))}`;
-    const secp256k1SpendingPubHex = `0x${(0, import_utils59.bytesToHex)(import_secp256k19.secp256k1.getPublicKey(scanKey, true))}`;
+    const viewingKeyHex = `0x${(0, import_utils60.bytesToHex)(viewingKey)}`;
+    const ed25519SpendingPubHex = `0x${(0, import_utils60.bytesToHex)(import_ed2551910.ed25519.getPublicKey(scanKey))}`;
+    const secp256k1SpendingPubHex = `0x${(0, import_utils60.bytesToHex)(import_secp256k19.secp256k1.getPublicKey(scanKey, true))}`;
     for (const transfer of transfers) {
       try {
         if (!transfer || typeof transfer !== "object") {
@@ -40211,7 +40482,7 @@ function createMockSolanaAdapter(config = {}) {
 var import_sha24 = require("@noble/hashes/sha2");
 var import_ed2551911 = require("@noble/curves/ed25519");
 init_stealth2();
-var ED25519_ORDER3 = BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed");
+init_utils();
 
 // src/wallet/ethereum/adapter.ts
 var import_types41 = require("@sip-protocol/types");
@@ -41316,7 +41587,7 @@ var import_types64 = require("@sip-protocol/types");
 // src/wallet/near/adapter.ts
 var import_ed2551913 = require("@noble/curves/ed25519");
 var import_sha26 = require("@noble/hashes/sha2");
-var import_utils61 = require("@noble/hashes/utils");
+var import_utils63 = require("@noble/hashes/utils");
 var import_types66 = require("@sip-protocol/types");
 
 // src/chains/near/stealth.ts
@@ -41523,16 +41794,16 @@ function validateNEARStealthAddress(stealthAddress) {
 }
 
 // src/wallet/near/adapter.ts
-var ED25519_ORDER4 = 2n ** 252n + 27742317777372353535851937790883648493n;
+var ED25519_ORDER3 = 2n ** 252n + 27742317777372353535851937790883648493n;
 
 // src/wallet/near/wallet-selector.ts
 var import_sha27 = require("@noble/hashes/sha2");
-var import_utils63 = require("@noble/hashes/utils");
+var import_utils65 = require("@noble/hashes/utils");
 var import_ed2551915 = require("@noble/curves/ed25519");
 
 // src/chains/near/implicit-account.ts
 var import_ed2551914 = require("@noble/curves/ed25519");
-var import_utils62 = require("@noble/hashes/utils");
+var import_utils64 = require("@noble/hashes/utils");
 init_errors();
 init_validation();
 
@@ -41576,12 +41847,12 @@ function createAnnouncementMemo2(ephemeralPublicKey, viewTag) {
 
 // src/wallet/near/my-near-wallet.ts
 var import_sha28 = require("@noble/hashes/sha2");
-var import_utils64 = require("@noble/hashes/utils");
+var import_utils66 = require("@noble/hashes/utils");
 var import_ed2551916 = require("@noble/curves/ed25519");
 
 // src/wallet/near/meteor-wallet.ts
 var import_sha29 = require("@noble/hashes/sha2");
-var import_utils65 = require("@noble/hashes/utils");
+var import_utils67 = require("@noble/hashes/utils");
 var import_ed2551917 = require("@noble/curves/ed25519");
 
 // src/wallet/hardware/types.ts
@@ -42194,7 +42465,7 @@ function createLedgerAdapter(config) {
 // src/wallet/hardware/ledger-privacy.ts
 var import_secp256k113 = require("@noble/curves/secp256k1");
 var import_sha25628 = require("@noble/hashes/sha256");
-var import_utils66 = require("@noble/hashes/utils");
+var import_utils68 = require("@noble/hashes/utils");
 var import_types70 = require("@sip-protocol/types");
 
 // src/wallet/hardware/trezor.ts
@@ -42637,7 +42908,7 @@ function createTrezorAdapter(config) {
 
 // src/wallet/hardware/mock.ts
 var import_types74 = require("@sip-protocol/types");
-var import_utils67 = require("@noble/hashes/utils");
+var import_utils69 = require("@noble/hashes/utils");
 var MockLedgerAdapter = class extends BaseWalletAdapter {
   chain;
   name = "mock-ledger";
@@ -42882,15 +43153,15 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = (0, import_utils67.randomBytes)(20);
+    const bytes = (0, import_utils69.randomBytes)(20);
     bytes[0] = index;
-    return `0x${(0, import_utils67.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils69.bytesToHex)(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = (0, import_utils67.randomBytes)(33);
+    const bytes = (0, import_utils69.randomBytes)(33);
     bytes[0] = 2;
     bytes[1] = index;
-    return `0x${(0, import_utils67.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils69.bytesToHex)(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -42899,7 +43170,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 11;
     }
     sig[64] = 27;
-    return `0x${(0, import_utils67.bytesToHex)(sig)}`;
+    return `0x${(0, import_utils69.bytesToHex)(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -43088,15 +43359,15 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = (0, import_utils67.randomBytes)(20);
+    const bytes = (0, import_utils69.randomBytes)(20);
     bytes[0] = index + 100;
-    return `0x${(0, import_utils67.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils69.bytesToHex)(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = (0, import_utils67.randomBytes)(33);
+    const bytes = (0, import_utils69.randomBytes)(33);
     bytes[0] = 3;
     bytes[1] = index + 100;
-    return `0x${(0, import_utils67.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils69.bytesToHex)(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -43105,7 +43376,7 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 17;
     }
     sig[64] = 28;
-    return `0x${(0, import_utils67.bytesToHex)(sig)}`;
+    return `0x${(0, import_utils69.bytesToHex)(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -43125,7 +43396,7 @@ var import_types77 = require("@sip-protocol/types");
 init_solana();
 
 // src/solana/noir-verifier.ts
-var import_web316 = require("@solana/web3.js");
+var import_web318 = require("@solana/web3.js");
 
 // src/solana/noir-verifier-types.ts
 init_endpoints();
@@ -43216,6 +43487,8 @@ var SolanaNoirError = class extends Error {
     this.details = details;
     this.name = "SolanaNoirError";
   }
+  code;
+  details;
 };
 var MAX_PROOF_SIZE_BYTES = 4096;
 var MAX_PUBLIC_INPUTS = 32;
@@ -43250,7 +43523,7 @@ var SolanaNoirVerifier = class {
       commitment: config.commitment ?? "confirmed",
       maxComputeUnits: config.maxComputeUnits ?? 4e5
     };
-    this.connection = new import_web316.Connection(this.config.rpcUrl, this.config.commitment);
+    this.connection = new import_web318.Connection(this.config.rpcUrl, this.config.commitment);
   }
   /**
    * Get the Solana connection
@@ -43502,16 +43775,16 @@ var SolanaNoirVerifier = class {
           error: `Proof requires ${computeUnits} CU, max is ${this.config.maxComputeUnits}`
         };
       }
-      const transaction = new import_web316.Transaction();
+      const transaction = new import_web318.Transaction();
       transaction.add(
-        import_web316.ComputeBudgetProgram.setComputeUnitLimit({ units: this.config.maxComputeUnits })
+        import_web318.ComputeBudgetProgram.setComputeUnitLimit({ units: this.config.maxComputeUnits })
       );
       transaction.add(instruction);
       const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash(
         this.config.commitment
       );
       transaction.recentBlockhash = blockhash;
-      transaction.feePayer = new import_web316.PublicKey(wallet.publicKey.toBase58());
+      transaction.feePayer = new import_web318.PublicKey(wallet.publicKey.toBase58());
       const signedTransaction = await wallet.signTransaction(transaction);
       const signature = await this.connection.sendRawTransaction(signedTransaction.serialize());
       const confirmation = await this.connection.confirmTransaction(
@@ -43553,8 +43826,8 @@ var SolanaNoirVerifier = class {
    */
   createSunspotVerifyInstruction(proof, programId) {
     const serialized = this.serializeProofForSunspot(proof);
-    return new import_web316.TransactionInstruction({
-      programId: new import_web316.PublicKey(programId),
+    return new import_web318.TransactionInstruction({
+      programId: new import_web318.PublicKey(programId),
       keys: [],
       // Sunspot verifiers don't require any accounts
       data: serialized
@@ -43728,8 +44001,8 @@ var SolanaNoirVerifier = class {
   }
   async hashBytes(bytes) {
     const { sha256: sha25642 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex65 } = await import("@noble/hashes/utils");
-    return bytesToHex65(sha25642(bytes));
+    const { bytesToHex: bytesToHex64 } = await import("@noble/hashes/utils");
+    return bytesToHex64(sha25642(bytes));
   }
   hexToBytes(hex) {
     const h = hex.startsWith("0x") ? hex.slice(2) : hex;
@@ -43766,8 +44039,8 @@ function createMainnetVerifier(config = {}) {
 }
 
 // src/solana/jito-relayer.ts
-var import_web317 = require("@solana/web3.js");
-var import_utils68 = require("@noble/hashes/utils");
+var import_web319 = require("@solana/web3.js");
+var import_bs58 = __toESM(require("bs58"));
 var JITO_BLOCK_ENGINES = {
   mainnet: {
     amsterdam: "https://amsterdam.mainnet.block-engine.jito.wtf/api/v1",
@@ -43816,8 +44089,10 @@ var JitoRelayerError = class extends Error {
     this.details = details;
     this.name = "JitoRelayerError";
   }
+  code;
+  details;
 };
-var JitoRelayer = class {
+var JitoRelayer = class _JitoRelayer {
   connection;
   blockEngineUrl;
   defaultTipLamports;
@@ -43826,7 +44101,7 @@ var JitoRelayer = class {
   submissionTimeout;
   constructor(config = {}) {
     this.blockEngineUrl = config.blockEngineUrl ?? JITO_BLOCK_ENGINES.mainnet.ny;
-    this.connection = new import_web317.Connection(
+    this.connection = new import_web319.Connection(
       config.rpcUrl ?? "https://api.mainnet-beta.solana.com",
       "confirmed"
     );
@@ -43835,6 +44110,11 @@ var JitoRelayer = class {
     this.maxRetries = config.maxRetries ?? JITO_DEFAULTS.maxRetries;
     this.submissionTimeout = config.submissionTimeout ?? JITO_DEFAULTS.submissionTimeout;
   }
+  // ─── Static Helpers ─────────────────────────────────────────────────────────
+  /** Encode a 64-byte ed25519 signature as a base58 string (Solana canonical form). */
+  static encodeSignature(sig) {
+    return import_bs58.default.encode(sig);
+  }
   // ─── Public Methods ─────────────────────────────────────────────────────────
   /**
    * Submit a bundle of transactions to Jito
@@ -43886,11 +44166,11 @@ var JitoRelayer = class {
       }
     }
     const signatures = bundleTransactions.map((tx) => {
-      if (tx instanceof import_web317.VersionedTransaction) {
-        return (0, import_utils68.bytesToHex)(tx.signatures[0]);
-      } else {
-        return tx.signature?.toString() ?? "";
+      if (tx instanceof import_web319.VersionedTransaction) {
+        return _JitoRelayer.encodeSignature(tx.signatures[0]);
       }
+      const sig = tx.signature;
+      return sig ? _JitoRelayer.encodeSignature(sig) : "";
     });
     if (request.waitForConfirmation) {
       const status = await this.waitForBundleConfirmation(bundleId, lastValidBlockHeight);
@@ -43922,13 +44202,30 @@ var JitoRelayer = class {
   async relayTransaction(request) {
     this.log("Relaying transaction");
     try {
+      if (request.tipPayer) {
+        const bundle = await this.submitBundle({
+          transactions: [request.transaction],
+          tipLamports: request.tipLamports,
+          tipPayer: request.tipPayer,
+          waitForConfirmation: request.waitForConfirmation
+        });
+        return {
+          signature: bundle.signatures[bundle.signatures.length - 1] ?? "",
+          bundleId: bundle.bundleId,
+          status: bundle.status === "landed" ? "confirmed" : bundle.status === "submitted" ? "submitted" : "failed",
+          slot: bundle.slot,
+          error: bundle.error,
+          relayed: true
+        };
+      }
       const serializedTx = Buffer.from(request.transaction.serialize()).toString("base64");
       const bundleId = await this.sendBundle([serializedTx]);
       let signature;
-      if (request.transaction instanceof import_web317.VersionedTransaction) {
-        signature = (0, import_utils68.bytesToHex)(request.transaction.signatures[0]);
+      if (request.transaction instanceof import_web319.VersionedTransaction) {
+        signature = _JitoRelayer.encodeSignature(request.transaction.signatures[0]);
       } else {
-        signature = request.transaction.signature?.toString() ?? "";
+        const sig = request.transaction.signature;
+        signature = sig ? _JitoRelayer.encodeSignature(sig) : "";
       }
       if (request.waitForConfirmation) {
         const { lastValidBlockHeight } = await this.connection.getLatestBlockhash();
@@ -43978,7 +44275,7 @@ var JitoRelayer = class {
    */
   getRandomTipAccount() {
     const index = Math.floor(Math.random() * JITO_TIP_ACCOUNTS.length);
-    return new import_web317.PublicKey(JITO_TIP_ACCOUNTS[index]);
+    return new import_web319.PublicKey(JITO_TIP_ACCOUNTS[index]);
   }
   // ─── Private Methods ────────────────────────────────────────────────────────
   /**
@@ -43986,7 +44283,7 @@ var JitoRelayer = class {
    */
   createTipInstruction(payer, tipLamports) {
     const tipAccount = this.getRandomTipAccount();
-    return import_web317.SystemProgram.transfer({
+    return import_web319.SystemProgram.transfer({
       fromPubkey: payer,
       toPubkey: tipAccount,
       lamports: tipLamports
@@ -43996,7 +44293,7 @@ var JitoRelayer = class {
    * Prepare transactions for bundle submission
    */
   async prepareBundleTransactions(transactions, tipInstruction, tipPayer, blockhash) {
-    const tipTx = new import_web317.Transaction();
+    const tipTx = new import_web319.Transaction();
     tipTx.add(tipInstruction);
     tipTx.recentBlockhash = blockhash;
     tipTx.feePayer = tipPayer.publicKey;
@@ -44151,15 +44448,15 @@ function createMainnetRelayer(rpcUrl) {
 // src/chains/near/commitment.ts
 var import_ed2551918 = require("@noble/curves/ed25519");
 var import_sha210 = require("@noble/hashes/sha2");
-var import_utils69 = require("@noble/hashes/utils");
+var import_utils70 = require("@noble/hashes/utils");
 init_errors();
 init_validation();
 var H_DOMAIN3 = "SIP-NEAR-PEDERSEN-GENERATOR-H-v1";
 var G3 = import_ed2551918.ed25519.ExtendedPoint.BASE;
-var ED25519_ORDER5 = 2n ** 252n + 27742317777372353535851937790883648493n;
+var ED25519_ORDER4 = 2n ** 252n + 27742317777372353535851937790883648493n;
 var ED25519_COFACTOR2 = 8n;
 var MAX_NEAR_AMOUNT = 2n ** 128n - 1n;
-var MAX_COMMITMENT_VALUE = ED25519_ORDER5 - 1n;
+var MAX_COMMITMENT_VALUE = ED25519_ORDER4 - 1n;
 var H3 = generateH3();
 function generateH3() {
   let counter = 0;
@@ -44172,7 +44469,7 @@ function generateH3() {
       if (!point.equals(import_ed2551918.ed25519.ExtendedPoint.ZERO)) {
         const gBytes = G3.toRawBytes();
         const hBytes = point.toRawBytes();
-        if ((0, import_utils69.bytesToHex)(gBytes) !== (0, import_utils69.bytesToHex)(hBytes)) {
+        if ((0, import_utils70.bytesToHex)(gBytes) !== (0, import_utils70.bytesToHex)(hBytes)) {
           return point;
         }
       }
@@ -44216,20 +44513,20 @@ function commitNEAR(value, blinding) {
   if (value < 0n) {
     throw new ValidationError("must be non-negative", "value");
   }
-  if (value >= ED25519_ORDER5) {
+  if (value >= ED25519_ORDER4) {
     throw new ValidationError(
       "must be less than curve order",
       "value",
-      { curveOrder: ED25519_ORDER5.toString(16) }
+      { curveOrder: ED25519_ORDER4.toString(16) }
     );
   }
-  const r = blinding ?? (0, import_utils69.randomBytes)(32);
+  const r = blinding ?? (0, import_utils70.randomBytes)(32);
   if (r.length !== 32) {
     throw new ValidationError("must be 32 bytes", "blinding", { received: r.length });
   }
-  const rScalar = bytesToBigInt4(r) % ED25519_ORDER5;
+  const rScalar = bytesToBigInt4(r) % ED25519_ORDER4;
   if (rScalar === 0n) {
-    return commitNEAR(value, (0, import_utils69.randomBytes)(32));
+    return commitNEAR(value, (0, import_utils70.randomBytes)(32));
   }
   let C;
   if (value === 0n) {
@@ -44241,8 +44538,8 @@ function commitNEAR(value, blinding) {
   }
   const rScalarBytes = bigIntToBytes4(rScalar, 32);
   return {
-    commitment: `0x${(0, import_utils69.bytesToHex)(C.toRawBytes())}`,
-    blinding: `0x${(0, import_utils69.bytesToHex)(rScalarBytes)}`
+    commitment: `0x${(0, import_utils70.bytesToHex)(C.toRawBytes())}`,
+    blinding: `0x${(0, import_utils70.bytesToHex)(rScalarBytes)}`
   };
 }
 function verifyOpeningNEAR(commitment, value, blinding) {
@@ -44250,7 +44547,7 @@ function verifyOpeningNEAR(commitment, value, blinding) {
     const commitmentBytes = hexToBytes38(commitment.slice(2));
     const C = import_ed2551918.ed25519.ExtendedPoint.fromHex(commitmentBytes);
     const blindingBytes = hexToBytes38(blinding.slice(2));
-    const rScalar = bytesToBigInt4(blindingBytes) % ED25519_ORDER5;
+    const rScalar = bytesToBigInt4(blindingBytes) % ED25519_ORDER4;
     let expected;
     if (value === 0n) {
       expected = H3.multiply(rScalar);
@@ -44274,7 +44571,7 @@ function commitNEP141Token(amount, tokenContract, decimals, blinding) {
       { max: MAX_NEAR_AMOUNT.toString() }
     );
   }
-  if (amount >= ED25519_ORDER5) {
+  if (amount >= ED25519_ORDER4) {
     throw new ValidationError(
       "Amount exceeds maximum committable value (curve order)",
       "amount",
@@ -44335,7 +44632,7 @@ function addCommitmentsNEAR(c1, c2) {
   }
   const sum = point1.add(point2);
   return {
-    commitment: `0x${(0, import_utils69.bytesToHex)(sum.toRawBytes())}`
+    commitment: `0x${(0, import_utils70.bytesToHex)(sum.toRawBytes())}`
   };
 }
 function subtractCommitmentsNEAR(c1, c2) {
@@ -44364,7 +44661,7 @@ function subtractCommitmentsNEAR(c1, c2) {
     };
   }
   return {
-    commitment: `0x${(0, import_utils69.bytesToHex)(diff.toRawBytes())}`
+    commitment: `0x${(0, import_utils70.bytesToHex)(diff.toRawBytes())}`
   };
 }
 function addBlindingsNEAR(b1, b2) {
@@ -44378,9 +44675,9 @@ function addBlindingsNEAR(b1, b2) {
   const b2Bytes = hexToBytes38(b2.slice(2));
   const b1Scalar = bytesToBigInt4(b1Bytes);
   const b2Scalar = bytesToBigInt4(b2Bytes);
-  const sum = (b1Scalar + b2Scalar) % ED25519_ORDER5;
+  const sum = (b1Scalar + b2Scalar) % ED25519_ORDER4;
   const sumBytes = bigIntToBytes4(sum, 32);
-  return `0x${(0, import_utils69.bytesToHex)(sumBytes)}`;
+  return `0x${(0, import_utils70.bytesToHex)(sumBytes)}`;
 }
 function subtractBlindingsNEAR(b1, b2) {
   if (!isValidHex(b1)) {
@@ -44393,24 +44690,24 @@ function subtractBlindingsNEAR(b1, b2) {
   const b2Bytes = hexToBytes38(b2.slice(2));
   const b1Scalar = bytesToBigInt4(b1Bytes);
   const b2Scalar = bytesToBigInt4(b2Bytes);
-  const diff = (b1Scalar - b2Scalar + ED25519_ORDER5) % ED25519_ORDER5;
+  const diff = (b1Scalar - b2Scalar + ED25519_ORDER4) % ED25519_ORDER4;
   const diffBytes = bigIntToBytes4(diff, 32);
-  return `0x${(0, import_utils69.bytesToHex)(diffBytes)}`;
+  return `0x${(0, import_utils70.bytesToHex)(diffBytes)}`;
 }
 function getGeneratorsNEAR() {
   return {
-    G: `0x${(0, import_utils69.bytesToHex)(G3.toRawBytes())}`,
-    H: `0x${(0, import_utils69.bytesToHex)(H3.toRawBytes())}`
+    G: `0x${(0, import_utils70.bytesToHex)(G3.toRawBytes())}`,
+    H: `0x${(0, import_utils70.bytesToHex)(H3.toRawBytes())}`
   };
 }
 function generateBlindingNEAR() {
-  const bytes = (0, import_utils69.randomBytes)(32);
-  const scalar = bytesToBigInt4(bytes) % ED25519_ORDER5;
+  const bytes = (0, import_utils70.randomBytes)(32);
+  const scalar = bytesToBigInt4(bytes) % ED25519_ORDER4;
   if (scalar === 0n) {
     return generateBlindingNEAR();
   }
   const scalarBytes = bigIntToBytes4(scalar, 32);
-  return `0x${(0, import_utils69.bytesToHex)(scalarBytes)}`;
+  return `0x${(0, import_utils70.bytesToHex)(scalarBytes)}`;
 }
 
 // src/chains/near/viewing-key.ts
@@ -44418,7 +44715,7 @@ var import_ed2551919 = require("@noble/curves/ed25519");
 var import_sha25629 = require("@noble/hashes/sha256");
 var import_hmac7 = require("@noble/hashes/hmac");
 var import_hkdf5 = require("@noble/hashes/hkdf");
-var import_utils70 = require("@noble/hashes/utils");
+var import_utils71 = require("@noble/hashes/utils");
 var import_chacha6 = require("@noble/ciphers/chacha.js");
 init_errors();
 init_validation();
@@ -44434,7 +44731,7 @@ function generateNEARViewingKeyFromSpending(spendingPrivateKey, label) {
       "spendingPrivateKey"
     );
   }
-  const spendingBytes = (0, import_utils70.hexToBytes)(spendingPrivateKey.slice(2));
+  const spendingBytes = (0, import_utils71.hexToBytes)(spendingPrivateKey.slice(2));
   if (spendingBytes.length !== 32) {
     throw new ValidationError(
       "spendingPrivateKey must be 32 bytes",
@@ -44445,15 +44742,15 @@ function generateNEARViewingKeyFromSpending(spendingPrivateKey, label) {
   try {
     viewingPrivateBytes = (0, import_hmac7.hmac)(
       import_sha25629.sha256,
-      (0, import_utils70.utf8ToBytes)(VIEWING_KEY_CONTEXT3),
+      (0, import_utils71.utf8ToBytes)(VIEWING_KEY_CONTEXT3),
       spendingBytes
     );
     const viewingPublicBytes = import_ed2551919.ed25519.getPublicKey(viewingPrivateBytes);
     const hashBytes = (0, import_sha25629.sha256)(viewingPublicBytes);
     return {
-      privateKey: `0x${(0, import_utils70.bytesToHex)(viewingPrivateBytes)}`,
-      publicKey: `0x${(0, import_utils70.bytesToHex)(viewingPublicBytes)}`,
-      hash: `0x${(0, import_utils70.bytesToHex)(hashBytes)}`,
+      privateKey: `0x${(0, import_utils71.bytesToHex)(viewingPrivateBytes)}`,
+      publicKey: `0x${(0, import_utils71.bytesToHex)(viewingPublicBytes)}`,
+      hash: `0x${(0, import_utils71.bytesToHex)(hashBytes)}`,
       label,
       createdAt: Date.now()
     };
@@ -44463,14 +44760,14 @@ function generateNEARViewingKeyFromSpending(spendingPrivateKey, label) {
   }
 }
 function generateRandomNEARViewingKey(label) {
-  const privateBytes = (0, import_utils70.randomBytes)(32);
+  const privateBytes = (0, import_utils71.randomBytes)(32);
   try {
     const publicBytes = import_ed2551919.ed25519.getPublicKey(privateBytes);
     const hashBytes = (0, import_sha25629.sha256)(publicBytes);
     return {
-      privateKey: `0x${(0, import_utils70.bytesToHex)(privateBytes)}`,
-      publicKey: `0x${(0, import_utils70.bytesToHex)(publicBytes)}`,
-      hash: `0x${(0, import_utils70.bytesToHex)(hashBytes)}`,
+      privateKey: `0x${(0, import_utils71.bytesToHex)(privateBytes)}`,
+      publicKey: `0x${(0, import_utils71.bytesToHex)(publicBytes)}`,
+      hash: `0x${(0, import_utils71.bytesToHex)(hashBytes)}`,
       label,
       createdAt: Date.now()
     };
@@ -44485,7 +44782,7 @@ function computeNEARViewingKeyHash(viewingPublicKey) {
       "viewingPublicKey"
     );
   }
-  const publicBytes = (0, import_utils70.hexToBytes)(viewingPublicKey.slice(2));
+  const publicBytes = (0, import_utils71.hexToBytes)(viewingPublicKey.slice(2));
   if (publicBytes.length !== 32) {
     throw new ValidationError(
       "viewingPublicKey must be 32 bytes",
@@ -44493,7 +44790,7 @@ function computeNEARViewingKeyHash(viewingPublicKey) {
     );
   }
   const hashBytes = (0, import_sha25629.sha256)(publicBytes);
-  return `0x${(0, import_utils70.bytesToHex)(hashBytes)}`;
+  return `0x${(0, import_utils71.bytesToHex)(hashBytes)}`;
 }
 function computeNEARViewingKeyHashFromPrivate(viewingPrivateKey) {
   if (!viewingPrivateKey || !viewingPrivateKey.startsWith("0x")) {
@@ -44502,7 +44799,7 @@ function computeNEARViewingKeyHashFromPrivate(viewingPrivateKey) {
       "viewingPrivateKey"
     );
   }
-  const privateBytes = (0, import_utils70.hexToBytes)(viewingPrivateKey.slice(2));
+  const privateBytes = (0, import_utils71.hexToBytes)(viewingPrivateKey.slice(2));
   if (privateBytes.length !== 32) {
     throw new ValidationError(
       "viewingPrivateKey must be 32 bytes",
@@ -44512,7 +44809,7 @@ function computeNEARViewingKeyHashFromPrivate(viewingPrivateKey) {
   try {
     const publicBytes = import_ed2551919.ed25519.getPublicKey(privateBytes);
     const hashBytes = (0, import_sha25629.sha256)(publicBytes);
-    return `0x${(0, import_utils70.bytesToHex)(hashBytes)}`;
+    return `0x${(0, import_utils71.bytesToHex)(hashBytes)}`;
   } finally {
     secureWipe(privateBytes);
   }
@@ -44559,9 +44856,9 @@ function importNEARViewingKey(exported) {
       { expected: computedHash, received: exported.hash }
     );
   }
-  const privateBytes = (0, import_utils70.hexToBytes)(exported.privateKey.slice(2));
+  const privateBytes = (0, import_utils71.hexToBytes)(exported.privateKey.slice(2));
   try {
-    const derivedPublic = `0x${(0, import_utils70.bytesToHex)(import_ed2551919.ed25519.getPublicKey(privateBytes))}`;
+    const derivedPublic = `0x${(0, import_utils71.bytesToHex)(import_ed2551919.ed25519.getPublicKey(privateBytes))}`;
     if (derivedPublic !== exported.publicKey) {
       throw new ValidationError(
         "Public key does not match private key",
@@ -44580,10 +44877,10 @@ function importNEARViewingKey(exported) {
   };
 }
 function deriveEncryptionKey3(key, salt) {
-  const keyBytes = (0, import_utils70.hexToBytes)(key.slice(2));
+  const keyBytes = (0, import_utils71.hexToBytes)(key.slice(2));
   try {
-    const hkdfSalt = salt ?? (0, import_utils70.utf8ToBytes)(ENCRYPTION_DOMAIN3);
-    return (0, import_hkdf5.hkdf)(import_sha25629.sha256, keyBytes, hkdfSalt, (0, import_utils70.utf8ToBytes)("encryption"), 32);
+    const hkdfSalt = salt ?? (0, import_utils71.utf8ToBytes)(ENCRYPTION_DOMAIN3);
+    return (0, import_hkdf5.hkdf)(import_sha25629.sha256, keyBytes, hkdfSalt, (0, import_utils71.utf8ToBytes)("encryption"), 32);
   } finally {
     secureWipe(keyBytes);
   }
@@ -44591,13 +44888,13 @@ function deriveEncryptionKey3(key, salt) {
 function encryptForNEARViewing(data, viewingKey) {
   const encKey = deriveEncryptionKey3(viewingKey.privateKey);
   try {
-    const nonce = (0, import_utils70.randomBytes)(NONCE_SIZE4);
-    const plaintext = (0, import_utils70.utf8ToBytes)(JSON.stringify(data));
+    const nonce = (0, import_utils71.randomBytes)(NONCE_SIZE4);
+    const plaintext = (0, import_utils71.utf8ToBytes)(JSON.stringify(data));
     const cipher = (0, import_chacha6.xchacha20poly1305)(encKey, nonce);
     const ciphertext = cipher.encrypt(plaintext);
     return {
-      ciphertext: `0x${(0, import_utils70.bytesToHex)(ciphertext)}`,
-      nonce: `0x${(0, import_utils70.bytesToHex)(nonce)}`,
+      ciphertext: `0x${(0, import_utils71.bytesToHex)(ciphertext)}`,
+      nonce: `0x${(0, import_utils71.bytesToHex)(nonce)}`,
       viewingKeyHash: viewingKey.hash
     };
   } finally {
@@ -44614,8 +44911,8 @@ function decryptWithNEARViewing(encrypted, viewingKey) {
   }
   const encKey = deriveEncryptionKey3(viewingKey.privateKey);
   try {
-    const ciphertext = (0, import_utils70.hexToBytes)(encrypted.ciphertext.slice(2));
-    const nonce = (0, import_utils70.hexToBytes)(encrypted.nonce.slice(2));
+    const ciphertext = (0, import_utils71.hexToBytes)(encrypted.ciphertext.slice(2));
+    const nonce = (0, import_utils71.hexToBytes)(encrypted.nonce.slice(2));
     if (nonce.length !== NONCE_SIZE4) {
       throw new ValidationError(
         `Invalid nonce length: ${nonce.length}. Expected: ${NONCE_SIZE4}`,
@@ -44665,15 +44962,15 @@ function deriveNEARChildViewingKey(parentKey, childPath, label) {
   if (!childPath || typeof childPath !== "string") {
     throw new ValidationError("childPath must be a non-empty string", "childPath");
   }
-  const parentBytes = (0, import_utils70.hexToBytes)(parentKey.privateKey.slice(2));
+  const parentBytes = (0, import_utils71.hexToBytes)(parentKey.privateKey.slice(2));
   try {
-    const childBytes = (0, import_hmac7.hmac)(import_sha25629.sha256, (0, import_utils70.utf8ToBytes)(childPath), parentBytes);
+    const childBytes = (0, import_hmac7.hmac)(import_sha25629.sha256, (0, import_utils71.utf8ToBytes)(childPath), parentBytes);
     const publicBytes = import_ed2551919.ed25519.getPublicKey(childBytes);
     const hashBytes = (0, import_sha25629.sha256)(publicBytes);
     const result = {
-      privateKey: `0x${(0, import_utils70.bytesToHex)(childBytes)}`,
-      publicKey: `0x${(0, import_utils70.bytesToHex)(publicBytes)}`,
-      hash: `0x${(0, import_utils70.bytesToHex)(hashBytes)}`,
+      privateKey: `0x${(0, import_utils71.bytesToHex)(childBytes)}`,
+      publicKey: `0x${(0, import_utils71.bytesToHex)(publicBytes)}`,
+      hash: `0x${(0, import_utils71.bytesToHex)(hashBytes)}`,
       label: label ?? `${parentKey.label ?? "Key"}/${childPath}`,
       createdAt: Date.now()
     };
@@ -44690,7 +44987,7 @@ function getNEARViewingPublicKey(viewingPrivateKey) {
       "viewingPrivateKey"
     );
   }
-  const privateBytes = (0, import_utils70.hexToBytes)(viewingPrivateKey.slice(2));
+  const privateBytes = (0, import_utils71.hexToBytes)(viewingPrivateKey.slice(2));
   if (privateBytes.length !== 32) {
     throw new ValidationError(
       "viewingPrivateKey must be 32 bytes",
@@ -44699,7 +44996,7 @@ function getNEARViewingPublicKey(viewingPrivateKey) {
   }
   try {
     const publicBytes = import_ed2551919.ed25519.getPublicKey(privateBytes);
-    return `0x${(0, import_utils70.bytesToHex)(publicBytes)}`;
+    return `0x${(0, import_utils71.bytesToHex)(publicBytes)}`;
   } finally {
     secureWipe(privateBytes);
   }
@@ -44734,9 +45031,9 @@ function validateNEARViewingKey(viewingKey) {
       { expected: computedHash, received: viewingKey.hash }
     );
   }
-  const privateBytes = (0, import_utils70.hexToBytes)(viewingKey.privateKey.slice(2));
+  const privateBytes = (0, import_utils71.hexToBytes)(viewingKey.privateKey.slice(2));
   try {
-    const derivedPublic = `0x${(0, import_utils70.bytesToHex)(import_ed2551919.ed25519.getPublicKey(privateBytes))}`;
+    const derivedPublic = `0x${(0, import_utils71.bytesToHex)(import_ed2551919.ed25519.getPublicKey(privateBytes))}`;
     if (derivedPublic !== viewingKey.publicKey) {
       throw new ValidationError(
         "publicKey does not match privateKey",
@@ -44751,11 +45048,11 @@ function validateNEARViewingKey(viewingKey) {
 
 // src/chains/near/resolver.ts
 var import_ed2551920 = require("@noble/curves/ed25519");
-var import_utils71 = require("@noble/hashes/utils");
+var import_utils72 = require("@noble/hashes/utils");
 init_errors();
 init_validation();
 function nearSpendingPublicFromPrivate(spendingPrivateKey) {
-  return `0x${(0, import_utils71.bytesToHex)(import_ed2551920.ed25519.getPublicKey((0, import_utils71.hexToBytes)(spendingPrivateKey.slice(2))))}`;
+  return `0x${(0, import_utils72.bytesToHex)(import_ed2551920.ed25519.getPublicKey((0, import_utils72.hexToBytes)(spendingPrivateKey.slice(2))))}`;
 }
 function createNEARAnnouncementCache() {
   const entries = [];
@@ -44796,6 +45093,8 @@ var NEARRpcClient = class {
     this.rpcUrl = rpcUrl;
     this.timeout = timeout;
   }
+  rpcUrl;
+  timeout;
   async call(method, params) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.timeout);
@@ -45006,7 +45305,7 @@ var NEARStealthScanner = class {
             nearSpendingPublicFromPrivate(recipient.spendingPrivateKey)
           );
           if (isMatch) {
-            const stealthAddress = isImplicitAccount(announcement.stealthAddress) ? announcement.stealthAddress : (0, import_utils71.bytesToHex)((0, import_utils71.hexToBytes)(stealthPublicKey.slice(2)));
+            const stealthAddress = isImplicitAccount(announcement.stealthAddress) ? announcement.stealthAddress : (0, import_utils72.bytesToHex)((0, import_utils72.hexToBytes)(stealthPublicKey.slice(2)));
             let amount = metadata?.amount ?? 0n;
             if (amount === 0n && isImplicitAccount(stealthAddress)) {
               try {
@@ -45456,6 +45755,9 @@ var AllBackendsFailedError = class _AllBackendsFailedError extends Error {
     this.params = params;
     Object.setPrototypeOf(this, _AllBackendsFailedError.prototype);
   }
+  attemptedBackends;
+  errors;
+  params;
   name = "AllBackendsFailedError";
   /**
    * Get formatted error summary
@@ -46111,6 +46413,10 @@ var RateLimitExceededError = class extends Error {
     this.requestedTokens = requestedTokens;
     this.retryAfterMs = retryAfterMs;
   }
+  backend;
+  availableTokens;
+  requestedTokens;
+  retryAfterMs;
   name = "RateLimitExceededError";
 };
 var QueueFullError = class extends Error {
@@ -46122,6 +46428,9 @@ var QueueFullError = class extends Error {
     this.queueSize = queueSize;
     this.maxQueueSize = maxQueueSize;
   }
+  backend;
+  queueSize;
+  maxQueueSize;
   name = "QueueFullError";
 };
 var AcquireTimeoutError = class extends Error {
@@ -46130,6 +46439,8 @@ var AcquireTimeoutError = class extends Error {
     this.backend = backend;
     this.timeoutMs = timeoutMs;
   }
+  backend;
+  timeoutMs;
   name = "AcquireTimeoutError";
 };
 var RateLimiter = class {
@@ -47381,7 +47692,7 @@ function createPrivacyLogger(moduleName, config = {}) {
 }
 
 // src/privacy-backends/privacycash.ts
-var import_utils72 = require("@noble/hashes/utils");
+var import_utils73 = require("@noble/hashes/utils");
 var privacyCashLogger = createPrivacyLogger("PrivacyCash");
 var DEFAULT_ANONYMITY_SET = 50;
 var BASE_COST_LAMPORTS = BigInt(1e7);
@@ -47411,7 +47722,7 @@ var PRIVACYCASH_CAPABILITIES = {
 
 // src/privacy-backends/shadowwire.ts
 var import_shadowwire = require("@radr/shadowwire");
-var import_utils73 = require("@noble/hashes/utils");
+var import_utils74 = require("@noble/hashes/utils");
 var SHADOWWIRE_TOKEN_MINTS = {
   SOL: "So11111111111111111111111111111111111111112",
   USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
@@ -47470,8 +47781,8 @@ var COST_PER_ENCRYPTED_INPUT_WEI = BigInt("1000000000000000");
 
 // src/privacy-backends/magicblock.ts
 var import_ephemeral_rollups_sdk = require("@magicblock-labs/ephemeral-rollups-sdk");
-var import_web318 = require("@solana/web3.js");
-var import_utils74 = require("@noble/hashes/utils");
+var import_web320 = require("@solana/web3.js");
+var import_utils75 = require("@noble/hashes/utils");
 var magicBlockLogger = createPrivacyLogger("MagicBlock");
 
 // src/privacy-backends/cspl-types.ts
@@ -48161,7 +48472,7 @@ var CSPLClient = class {
 
 // src/privacy-backends/private-swap.ts
 var import_sha25630 = require("@noble/hashes/sha256");
-var import_utils75 = require("@noble/hashes/utils");
+var import_utils76 = require("@noble/hashes/utils");
 
 // src/privacy-backends/cspl-token.ts
 var CSPLTokenService = class {
@@ -50768,6 +51079,7 @@ var ProductionSafetyError = class extends Error {
     this.errors = errors;
     this.name = "ProductionSafetyError";
   }
+  errors;
 };
 function validateProductionConfig(config, options = {}) {
   const isProduction = isProductionEnvironment();
@@ -50872,7 +51184,7 @@ init_proxy();
 // src/sync/oblivious.ts
 var import_sha211 = require("@noble/hashes/sha2");
 var import_hmac8 = require("@noble/hashes/hmac");
-var import_utils76 = require("@noble/hashes/utils");
+var import_utils77 = require("@noble/hashes/utils");
 init_secure_memory();
 var DEFAULT_SYNC_CONFIG = {
   maxBatchSize: 1e3,
@@ -50883,7 +51195,7 @@ var DEFAULT_SYNC_CONFIG = {
   parallelSync: true
 };
 function generateSyncRandomness(epoch, durationSeconds = DEFAULT_SYNC_CONFIG.epochDurationSeconds) {
-  const value = (0, import_utils76.randomBytes)(32);
+  const value = (0, import_utils77.randomBytes)(32);
   const expiresAt = Date.now() + durationSeconds * 1e3;
   return {
     value,
@@ -50899,21 +51211,21 @@ function getCurrentEpoch(epochDurationSeconds = DEFAULT_SYNC_CONFIG.epochDuratio
 }
 var OBLIVIOUS_NULLIFIER_DOMAIN = "SIP-OBLIVIOUS-NULLIFIER-V1";
 function deriveObliviousNullifier(noteCommitment, spendingKey, syncRandomness) {
-  const commitmentBytes = (0, import_utils76.hexToBytes)(
+  const commitmentBytes = (0, import_utils77.hexToBytes)(
     noteCommitment.startsWith("0x") ? noteCommitment.slice(2) : noteCommitment
   );
-  const keyBytes = (0, import_utils76.hexToBytes)(
+  const keyBytes = (0, import_utils77.hexToBytes)(
     spendingKey.startsWith("0x") ? spendingKey.slice(2) : spendingKey
   );
   try {
-    const domain = (0, import_utils76.utf8ToBytes)(OBLIVIOUS_NULLIFIER_DOMAIN);
+    const domain = (0, import_utils77.utf8ToBytes)(OBLIVIOUS_NULLIFIER_DOMAIN);
     const message = new Uint8Array(domain.length + commitmentBytes.length + syncRandomness.value.length);
     message.set(domain, 0);
     message.set(commitmentBytes, domain.length);
     message.set(syncRandomness.value, domain.length + commitmentBytes.length);
     const nullifierBytes = (0, import_hmac8.hmac)(import_sha211.sha256, keyBytes, message);
     return {
-      nullifier: `0x${(0, import_utils76.bytesToHex)(nullifierBytes)}`,
+      nullifier: `0x${(0, import_utils77.bytesToHex)(nullifierBytes)}`,
       epoch: syncRandomness.epoch,
       chainId: "default"
       // Will be set by caller
@@ -50923,15 +51235,15 @@ function deriveObliviousNullifier(noteCommitment, spendingKey, syncRandomness) {
   }
 }
 function deriveTraditionalNullifier(noteCommitment, spendingKey) {
-  const commitmentBytes = (0, import_utils76.hexToBytes)(
+  const commitmentBytes = (0, import_utils77.hexToBytes)(
     noteCommitment.startsWith("0x") ? noteCommitment.slice(2) : noteCommitment
   );
-  const keyBytes = (0, import_utils76.hexToBytes)(
+  const keyBytes = (0, import_utils77.hexToBytes)(
     spendingKey.startsWith("0x") ? spendingKey.slice(2) : spendingKey
   );
   try {
     const nullifierBytes = (0, import_hmac8.hmac)(import_sha211.sha256, keyBytes, commitmentBytes);
-    return `0x${(0, import_utils76.bytesToHex)(nullifierBytes)}`;
+    return `0x${(0, import_utils77.bytesToHex)(nullifierBytes)}`;
   } finally {
     secureWipe(keyBytes);
   }
@@ -50976,7 +51288,7 @@ function createTimeWindowedKey(masterViewingKey, startTime, endTime, epochDurati
   for (let e = startEpoch; e <= endEpoch; e++) {
     epochs.push(e);
   }
-  const keyBytes = (0, import_utils76.hexToBytes)(
+  const keyBytes = (0, import_utils77.hexToBytes)(
     masterViewingKey.startsWith("0x") ? masterViewingKey.slice(2) : masterViewingKey
   );
   const windowData = new Uint8Array(16);
@@ -50987,11 +51299,11 @@ function createTimeWindowedKey(masterViewingKey, startTime, endTime, epochDurati
   const keyHash = (0, import_sha211.sha256)(derivedKey);
   secureWipe(keyBytes);
   return {
-    viewingKey: `0x${(0, import_utils76.bytesToHex)(derivedKey)}`,
+    viewingKey: `0x${(0, import_utils77.bytesToHex)(derivedKey)}`,
     windowStart: startTime,
     windowEnd: endTime,
     epochs,
-    hash: `0x${(0, import_utils76.bytesToHex)(keyHash)}`
+    hash: `0x${(0, import_utils77.bytesToHex)(keyHash)}`
   };
 }
 function isNoteInWindow(_note, _windowedKey) {
@@ -51014,10 +51326,12 @@ var ObliviousSyncError = class extends Error {
     this.context = context;
     this.name = "ObliviousSyncError";
   }
+  code;
+  context;
 };
 
 // src/sync/mock-provider.ts
-var import_utils77 = require("@noble/hashes/utils");
+var import_utils78 = require("@noble/hashes/utils");
 var DEFAULT_MOCK_CONFIG = {
   chains: ["ethereum", "solana", "near"],
   latencyMs: 100,
@@ -51114,7 +51428,7 @@ var MockObliviousSyncProvider = class {
       merkleProofs,
       syncHeight: this.config.blockHeight,
       timestamp: Date.now(),
-      queryHash: `0x${(0, import_utils77.bytesToHex)((0, import_utils77.randomBytes)(32))}`
+      queryHash: `0x${(0, import_utils78.bytesToHex)((0, import_utils78.randomBytes)(32))}`
     };
   }
   async getCurrentHeight(chainId) {
@@ -51195,23 +51509,23 @@ var MockObliviousSyncProvider = class {
   generateMockNote(blockRange) {
     const blockNumber = blockRange.startBlock + BigInt(Math.floor(Math.random() * Number(blockRange.endBlock - blockRange.startBlock)));
     return {
-      commitment: `0x${(0, import_utils77.bytesToHex)((0, import_utils77.randomBytes)(32))}`,
-      encryptedData: `0x${(0, import_utils77.bytesToHex)((0, import_utils77.randomBytes)(128))}`,
+      commitment: `0x${(0, import_utils78.bytesToHex)((0, import_utils78.randomBytes)(32))}`,
+      encryptedData: `0x${(0, import_utils78.bytesToHex)((0, import_utils78.randomBytes)(128))}`,
       blockNumber,
-      txHash: `0x${(0, import_utils77.bytesToHex)((0, import_utils77.randomBytes)(32))}`,
+      txHash: `0x${(0, import_utils78.bytesToHex)((0, import_utils78.randomBytes)(32))}`,
       chainId: blockRange.chainId
     };
   }
   generateMockMerkleProof(leaf) {
     const siblings = [];
     for (let i = 0; i < 20; i++) {
-      siblings.push(`0x${(0, import_utils77.bytesToHex)((0, import_utils77.randomBytes)(32))}`);
+      siblings.push(`0x${(0, import_utils78.bytesToHex)((0, import_utils78.randomBytes)(32))}`);
     }
     return {
       leaf,
       siblings,
       index: BigInt(Math.floor(Math.random() * 1e6)),
-      root: `0x${(0, import_utils77.bytesToHex)((0, import_utils77.randomBytes)(32))}`
+      root: `0x${(0, import_utils78.bytesToHex)((0, import_utils78.randomBytes)(32))}`
     };
   }
 };
@@ -54533,6 +54847,7 @@ var ProofWorker = class _ProofWorker {
   bpsToPercent,
   browserBytesToHex,
   browserHexToBytes,
+  buildGaslessCashout,
   cacheKeyGenerator,
   calculateFeeForSwap,
   calculatePrivacyScore,
@@ -54555,6 +54870,7 @@ var ProofWorker = class _ProofWorker {
   computeAttestationHash,
   computeNEARViewingKeyHash,
   computeNEARViewingKeyHashFromPrivate,
+  computeRelayerFee,
   computeTweakedKey,
   configureLogger,
   convertFromSIP,
@@ -54659,6 +54975,7 @@ var ProofWorker = class _ProofWorker {
   deriveSecp256k1StealthPrivateKeyV1,
   deriveStealthPrivateKey,
   deriveStealthPrivateKeyV1,
+  deriveStealthSigner,
   deriveSuiStealthPrivateKey,
   deriveTraditionalNullifier,
   deriveViewingKey,
@@ -54856,11 +55173,13 @@ var ProofWorker = class _ProofWorker {
   serializePayment,
   setLogLevel,
   signAttestationMessage,
+  signEd25519WithScalar,
   silenceLogger,
   solanaAddressToEd25519PublicKey,
   solanaOptimizations,
   solanaPublicKeyToHex,
   stealthKeyToCosmosAddress,
+  submitGaslessCashout,
   subtractBlindings,
   subtractBlindingsNEAR,
   subtractCommitments,