@sip-protocol/sdk 0.11.1 → 0.12.0

package/dist/{chunk-L4RKPNIJ.mjs → chunk-4EHEBTKP.mjs}

@@ -34,7 +34,7 @@ import {
   validateEd25519StealthAddress,
   validateEd25519StealthMetaAddress,
   verifyOpening
-} from "./chunk-7IUKXWDN.mjs";
+} from "./chunk-MKTCJPFH.mjs";
 import {
   ProofGenerationError
 } from "./chunk-HOR7PM3M.mjs";
@@ -54,7 +54,7 @@ import {
 } from "./chunk-KXETSSKP.mjs";
 import {
   __export
-} from "./chunk-XGB3TDIC.mjs";
+} from "./chunk-S3F4CPQ5.mjs";
 
 // src/sip.ts
 import {
@@ -2682,10 +2682,10 @@ var SIP = class {
         "chain"
       );
     }
-    const { sendPrivateSPLTransfer: sendPrivateSPLTransfer2 } = await import("./solana-7QOA3HBZ.mjs");
+    const { sendPrivateSPLTransfer: sendPrivateSPLTransfer2 } = await import("./solana-VKZI66MK.mjs");
     const { PublicKey: SolanaPublicKey } = await import("@solana/web3.js");
     const { getAssociatedTokenAddress } = await import("@solana/spl-token");
-    const { SOLANA_TOKEN_MINTS: SOLANA_TOKEN_MINTS3 } = await import("./constants-DCJYTIU3.mjs");
+    const { SOLANA_TOKEN_MINTS: SOLANA_TOKEN_MINTS3 } = await import("./constants-NCGOQF7S.mjs");
     let mint;
     if (params.token in SOLANA_TOKEN_MINTS3) {
       mint = new SolanaPublicKey(SOLANA_TOKEN_MINTS3[params.token]);
@@ -3959,46 +3959,46 @@ var ComplianceProofProvider = class {
   }
   async hashViewingKey(viewingKey) {
     const { sha256: sha25635 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex57 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex56 } = await import("@noble/hashes/utils");
     const keyString = typeof viewingKey === "string" ? viewingKey : JSON.stringify(viewingKey);
     const encoder = new TextEncoder();
     const keyBytes = encoder.encode(keyString);
-    return bytesToHex57(sha25635(keyBytes));
+    return bytesToHex56(sha25635(keyBytes));
   }
   async computeDecryptionCommitment(viewingKey, encryptedData) {
     const { sha256: sha25635 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex57 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex56 } = 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 bytesToHex57(sha25635(preimage));
+    return bytesToHex56(sha25635(preimage));
   }
   async computeAuditorHash(auditorPublicKey, transactionHash) {
     const { sha256: sha25635 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex57 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex56 } = 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 bytesToHex57(sha25635(preimage));
+    return bytesToHex56(sha25635(preimage));
   }
   async computeAddressCommitment(address, blinding) {
     const { sha256: sha25635 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex57 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex56 } = 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 bytesToHex57(sha25635(preimage));
+    return bytesToHex56(sha25635(preimage));
   }
   async computeNonMembershipProof(senderAddress, recipientAddress, _sanctionsListRoot) {
     const { sha256: sha25635 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex57 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex56 } = 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 bytesToHex57(sha25635(preimage));
+    return bytesToHex56(sha25635(preimage));
   }
   async computeBalanceCommitment(balance, blinding) {
     const { sha256: sha25635 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex57 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex56 } = await import("@noble/hashes/utils");
     const balanceBytes = new Uint8Array(8);
     let v = balance;
     for (let i = 7; i >= 0; i--) {
@@ -4006,11 +4006,11 @@ var ComplianceProofProvider = class {
       v = v >> 8n;
     }
     const preimage = new Uint8Array([...balanceBytes, ...blinding.slice(0, 32)]);
-    return bytesToHex57(sha25635(preimage));
+    return bytesToHex56(sha25635(preimage));
   }
   async generateComplianceProofBytes(type, publicInputs) {
     const { sha256: sha25635 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex57 } = await import("@noble/hashes/utils");
+    const { bytesToHex: bytesToHex56 } = 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", ""))));
@@ -4021,7 +4021,7 @@ var ComplianceProofProvider = class {
     const hash2 = sha25635(preimage);
     let proofBytes = "";
     for (let i = 0; i < 8; i++) {
-      proofBytes += bytesToHex57(sha25635(new Uint8Array([...hash2, i])));
+      proofBytes += bytesToHex56(sha25635(new Uint8Array([...hash2, i])));
     }
     return proofBytes;
   }
@@ -10715,6 +10715,7 @@ var SmartRouter = class {
       log4.warn({ backend, error }, "Backend failed");
     });
   }
+  registry;
   cache;
   tracker;
   backendTimeoutMs;
@@ -11779,6 +11780,8 @@ var ZcashRPCError = class extends Error {
     this.data = data;
     this.name = "ZcashRPCError";
   }
+  code;
+  data;
   /**
    * Check if error is due to insufficient funds
    */
@@ -20817,7 +20820,6 @@ function createMockSolanaAdapter(config = {}) {
 // src/wallet/solana/privacy-adapter.ts
 import { sha256 as sha25623 } from "@noble/hashes/sha2";
 import { ed25519 as ed255193 } from "@noble/curves/ed25519";
-var ED25519_ORDER = BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed");
 
 // src/wallet/ethereum/adapter.ts
 import { WalletErrorCode as WalletErrorCode5 } from "@sip-protocol/types";
@@ -22457,7 +22459,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
    */
   async loadTransport() {
     try {
-      const module = await import("./TransportWebUSB-2KITI5HD.mjs");
+      const module = await import("./TransportWebUSB-TXDZJBGS.mjs");
       return module.default;
     } catch {
       throw new HardwareWalletError(
@@ -23812,6 +23814,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;
@@ -24291,11 +24295,11 @@ var SolanaNoirVerifier = class {
     try {
       switch (circuitType) {
         case "funding":
-          return await import("./funding_proof-ICFZ5LHY.mjs");
+          return await import("./funding_proof-X5IP4SG5.mjs");
         case "validity":
-          return await import("./validity_proof-3POXLPNY.mjs");
+          return await import("./validity_proof-2GVV6GA6.mjs");
         case "fulfillment":
-          return await import("./fulfillment_proof-ANHVPKTB.mjs");
+          return await import("./fulfillment_proof-WCEE5GGO.mjs");
         default:
           throw new SolanaNoirError(
             `Unknown circuit type: ${circuitType}`,
@@ -24324,8 +24328,8 @@ var SolanaNoirVerifier = class {
   }
   async hashBytes(bytes) {
     const { sha256: sha25635 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex57 } = await import("@noble/hashes/utils");
-    return bytesToHex57(sha25635(bytes));
+    const { bytesToHex: bytesToHex56 } = await import("@noble/hashes/utils");
+    return bytesToHex56(sha25635(bytes));
   }
   hexToBytes(hex) {
     const h = hex.startsWith("0x") ? hex.slice(2) : hex;
@@ -24369,7 +24373,7 @@ import {
   Transaction as Transaction2,
   SystemProgram
 } from "@solana/web3.js";
-import { bytesToHex as bytesToHex47 } from "@noble/hashes/utils";
+import bs58 from "bs58";
 var JITO_BLOCK_ENGINES = {
   mainnet: {
     amsterdam: "https://amsterdam.mainnet.block-engine.jito.wtf/api/v1",
@@ -24418,8 +24422,10 @@ var JitoRelayerError = class extends Error {
     this.details = details;
     this.name = "JitoRelayerError";
   }
+  code;
+  details;
 };
-var JitoRelayer = class {
+var JitoRelayer = class _JitoRelayer {
   connection;
   blockEngineUrl;
   defaultTipLamports;
@@ -24437,6 +24443,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 bs58.encode(sig);
+  }
   // ─── Public Methods ─────────────────────────────────────────────────────────
   /**
    * Submit a bundle of transactions to Jito
@@ -24489,10 +24500,10 @@ var JitoRelayer = class {
     }
     const signatures = bundleTransactions.map((tx) => {
       if (tx instanceof VersionedTransaction2) {
-        return bytesToHex47(tx.signatures[0]);
-      } else {
-        return tx.signature?.toString() ?? "";
+        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);
@@ -24524,13 +24535,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 VersionedTransaction2) {
-        signature = bytesToHex47(request.transaction.signatures[0]);
+        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();
@@ -24753,7 +24781,7 @@ function createMainnetRelayer(rpcUrl) {
 // src/chains/near/commitment.ts
 import { ed25519 as ed255199 } from "@noble/curves/ed25519";
 import { sha256 as sha25631 } from "@noble/hashes/sha2";
-import { bytesToHex as bytesToHex48, randomBytes as randomBytes19 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex47, randomBytes as randomBytes19 } from "@noble/hashes/utils";
 var H_DOMAIN = "SIP-NEAR-PEDERSEN-GENERATOR-H-v1";
 var G = ed255199.ExtendedPoint.BASE;
 var ED25519_ORDER3 = 2n ** 252n + 27742317777372353535851937790883648493n;
@@ -24772,7 +24800,7 @@ function generateH() {
       if (!point.equals(ed255199.ExtendedPoint.ZERO)) {
         const gBytes = G.toRawBytes();
         const hBytes = point.toRawBytes();
-        if (bytesToHex48(gBytes) !== bytesToHex48(hBytes)) {
+        if (bytesToHex47(gBytes) !== bytesToHex47(hBytes)) {
           return point;
         }
       }
@@ -24786,7 +24814,7 @@ function generateH() {
     { context: { domain: H_DOMAIN } }
   );
 }
-function bytesToBigInt(bytes) {
+function bytesToBigInt2(bytes) {
   let result = 0n;
   for (let i = bytes.length - 1; i >= 0; i--) {
     result = result * 256n + BigInt(bytes[i]);
@@ -24827,7 +24855,7 @@ function commitNEAR(value, blinding) {
   if (r.length !== 32) {
     throw new ValidationError("must be 32 bytes", "blinding", { received: r.length });
   }
-  const rScalar = bytesToBigInt(r) % ED25519_ORDER3;
+  const rScalar = bytesToBigInt2(r) % ED25519_ORDER3;
   if (rScalar === 0n) {
     return commitNEAR(value, randomBytes19(32));
   }
@@ -24841,8 +24869,8 @@ function commitNEAR(value, blinding) {
   }
   const rScalarBytes = bigIntToBytes(rScalar, 32);
   return {
-    commitment: `0x${bytesToHex48(C.toRawBytes())}`,
-    blinding: `0x${bytesToHex48(rScalarBytes)}`
+    commitment: `0x${bytesToHex47(C.toRawBytes())}`,
+    blinding: `0x${bytesToHex47(rScalarBytes)}`
   };
 }
 function verifyOpeningNEAR(commitment, value, blinding) {
@@ -24850,7 +24878,7 @@ function verifyOpeningNEAR(commitment, value, blinding) {
     const commitmentBytes = hexToBytes31(commitment.slice(2));
     const C = ed255199.ExtendedPoint.fromHex(commitmentBytes);
     const blindingBytes = hexToBytes31(blinding.slice(2));
-    const rScalar = bytesToBigInt(blindingBytes) % ED25519_ORDER3;
+    const rScalar = bytesToBigInt2(blindingBytes) % ED25519_ORDER3;
     let expected;
     if (value === 0n) {
       expected = H.multiply(rScalar);
@@ -24935,7 +24963,7 @@ function addCommitmentsNEAR(c1, c2) {
   }
   const sum = point1.add(point2);
   return {
-    commitment: `0x${bytesToHex48(sum.toRawBytes())}`
+    commitment: `0x${bytesToHex47(sum.toRawBytes())}`
   };
 }
 function subtractCommitmentsNEAR(c1, c2) {
@@ -24964,7 +24992,7 @@ function subtractCommitmentsNEAR(c1, c2) {
     };
   }
   return {
-    commitment: `0x${bytesToHex48(diff.toRawBytes())}`
+    commitment: `0x${bytesToHex47(diff.toRawBytes())}`
   };
 }
 function addBlindingsNEAR(b1, b2) {
@@ -24976,11 +25004,11 @@ function addBlindingsNEAR(b1, b2) {
   }
   const b1Bytes = hexToBytes31(b1.slice(2));
   const b2Bytes = hexToBytes31(b2.slice(2));
-  const b1Scalar = bytesToBigInt(b1Bytes);
-  const b2Scalar = bytesToBigInt(b2Bytes);
+  const b1Scalar = bytesToBigInt2(b1Bytes);
+  const b2Scalar = bytesToBigInt2(b2Bytes);
   const sum = (b1Scalar + b2Scalar) % ED25519_ORDER3;
   const sumBytes = bigIntToBytes(sum, 32);
-  return `0x${bytesToHex48(sumBytes)}`;
+  return `0x${bytesToHex47(sumBytes)}`;
 }
 function subtractBlindingsNEAR(b1, b2) {
   if (!isValidHex(b1)) {
@@ -24991,26 +25019,26 @@ function subtractBlindingsNEAR(b1, b2) {
   }
   const b1Bytes = hexToBytes31(b1.slice(2));
   const b2Bytes = hexToBytes31(b2.slice(2));
-  const b1Scalar = bytesToBigInt(b1Bytes);
-  const b2Scalar = bytesToBigInt(b2Bytes);
+  const b1Scalar = bytesToBigInt2(b1Bytes);
+  const b2Scalar = bytesToBigInt2(b2Bytes);
   const diff = (b1Scalar - b2Scalar + ED25519_ORDER3) % ED25519_ORDER3;
   const diffBytes = bigIntToBytes(diff, 32);
-  return `0x${bytesToHex48(diffBytes)}`;
+  return `0x${bytesToHex47(diffBytes)}`;
 }
 function getGeneratorsNEAR() {
   return {
-    G: `0x${bytesToHex48(G.toRawBytes())}`,
-    H: `0x${bytesToHex48(H.toRawBytes())}`
+    G: `0x${bytesToHex47(G.toRawBytes())}`,
+    H: `0x${bytesToHex47(H.toRawBytes())}`
   };
 }
 function generateBlindingNEAR() {
   const bytes = randomBytes19(32);
-  const scalar = bytesToBigInt(bytes) % ED25519_ORDER3;
+  const scalar = bytesToBigInt2(bytes) % ED25519_ORDER3;
   if (scalar === 0n) {
     return generateBlindingNEAR();
   }
   const scalarBytes = bigIntToBytes(scalar, 32);
-  return `0x${bytesToHex48(scalarBytes)}`;
+  return `0x${bytesToHex47(scalarBytes)}`;
 }
 
 // src/chains/near/viewing-key.ts
@@ -25018,7 +25046,7 @@ import { ed25519 as ed2551910 } from "@noble/curves/ed25519";
 import { sha256 as sha25632 } from "@noble/hashes/sha256";
 import { hmac as hmac4 } from "@noble/hashes/hmac";
 import { hkdf as hkdf4 } from "@noble/hashes/hkdf";
-import { bytesToHex as bytesToHex49, hexToBytes as hexToBytes32, randomBytes as randomBytes20, utf8ToBytes as utf8ToBytes7 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex48, hexToBytes as hexToBytes32, randomBytes as randomBytes20, utf8ToBytes as utf8ToBytes7 } from "@noble/hashes/utils";
 import { xchacha20poly1305 as xchacha20poly13055 } from "@noble/ciphers/chacha.js";
 var VIEWING_KEY_CONTEXT = "SIP-NEAR-viewing-key-v1";
 var ENCRYPTION_DOMAIN2 = "SIP-NEAR-VIEWING-KEY-ENCRYPTION-V1";
@@ -25048,9 +25076,9 @@ function generateNEARViewingKeyFromSpending(spendingPrivateKey, label) {
     const viewingPublicBytes = ed2551910.getPublicKey(viewingPrivateBytes);
     const hashBytes = sha25632(viewingPublicBytes);
     return {
-      privateKey: `0x${bytesToHex49(viewingPrivateBytes)}`,
-      publicKey: `0x${bytesToHex49(viewingPublicBytes)}`,
-      hash: `0x${bytesToHex49(hashBytes)}`,
+      privateKey: `0x${bytesToHex48(viewingPrivateBytes)}`,
+      publicKey: `0x${bytesToHex48(viewingPublicBytes)}`,
+      hash: `0x${bytesToHex48(hashBytes)}`,
       label,
       createdAt: Date.now()
     };
@@ -25065,9 +25093,9 @@ function generateRandomNEARViewingKey(label) {
     const publicBytes = ed2551910.getPublicKey(privateBytes);
     const hashBytes = sha25632(publicBytes);
     return {
-      privateKey: `0x${bytesToHex49(privateBytes)}`,
-      publicKey: `0x${bytesToHex49(publicBytes)}`,
-      hash: `0x${bytesToHex49(hashBytes)}`,
+      privateKey: `0x${bytesToHex48(privateBytes)}`,
+      publicKey: `0x${bytesToHex48(publicBytes)}`,
+      hash: `0x${bytesToHex48(hashBytes)}`,
       label,
       createdAt: Date.now()
     };
@@ -25090,7 +25118,7 @@ function computeNEARViewingKeyHash(viewingPublicKey) {
     );
   }
   const hashBytes = sha25632(publicBytes);
-  return `0x${bytesToHex49(hashBytes)}`;
+  return `0x${bytesToHex48(hashBytes)}`;
 }
 function computeNEARViewingKeyHashFromPrivate(viewingPrivateKey) {
   if (!viewingPrivateKey || !viewingPrivateKey.startsWith("0x")) {
@@ -25109,7 +25137,7 @@ function computeNEARViewingKeyHashFromPrivate(viewingPrivateKey) {
   try {
     const publicBytes = ed2551910.getPublicKey(privateBytes);
     const hashBytes = sha25632(publicBytes);
-    return `0x${bytesToHex49(hashBytes)}`;
+    return `0x${bytesToHex48(hashBytes)}`;
   } finally {
     secureWipe(privateBytes);
   }
@@ -25158,7 +25186,7 @@ function importNEARViewingKey(exported) {
   }
   const privateBytes = hexToBytes32(exported.privateKey.slice(2));
   try {
-    const derivedPublic = `0x${bytesToHex49(ed2551910.getPublicKey(privateBytes))}`;
+    const derivedPublic = `0x${bytesToHex48(ed2551910.getPublicKey(privateBytes))}`;
     if (derivedPublic !== exported.publicKey) {
       throw new ValidationError(
         "Public key does not match private key",
@@ -25193,8 +25221,8 @@ function encryptForNEARViewing(data, viewingKey) {
     const cipher = xchacha20poly13055(encKey, nonce);
     const ciphertext = cipher.encrypt(plaintext);
     return {
-      ciphertext: `0x${bytesToHex49(ciphertext)}`,
-      nonce: `0x${bytesToHex49(nonce)}`,
+      ciphertext: `0x${bytesToHex48(ciphertext)}`,
+      nonce: `0x${bytesToHex48(nonce)}`,
       viewingKeyHash: viewingKey.hash
     };
   } finally {
@@ -25268,9 +25296,9 @@ function deriveNEARChildViewingKey(parentKey, childPath, label) {
     const publicBytes = ed2551910.getPublicKey(childBytes);
     const hashBytes = sha25632(publicBytes);
     const result = {
-      privateKey: `0x${bytesToHex49(childBytes)}`,
-      publicKey: `0x${bytesToHex49(publicBytes)}`,
-      hash: `0x${bytesToHex49(hashBytes)}`,
+      privateKey: `0x${bytesToHex48(childBytes)}`,
+      publicKey: `0x${bytesToHex48(publicBytes)}`,
+      hash: `0x${bytesToHex48(hashBytes)}`,
       label: label ?? `${parentKey.label ?? "Key"}/${childPath}`,
       createdAt: Date.now()
     };
@@ -25296,7 +25324,7 @@ function getNEARViewingPublicKey(viewingPrivateKey) {
   }
   try {
     const publicBytes = ed2551910.getPublicKey(privateBytes);
-    return `0x${bytesToHex49(publicBytes)}`;
+    return `0x${bytesToHex48(publicBytes)}`;
   } finally {
     secureWipe(privateBytes);
   }
@@ -25333,7 +25361,7 @@ function validateNEARViewingKey(viewingKey) {
   }
   const privateBytes = hexToBytes32(viewingKey.privateKey.slice(2));
   try {
-    const derivedPublic = `0x${bytesToHex49(ed2551910.getPublicKey(privateBytes))}`;
+    const derivedPublic = `0x${bytesToHex48(ed2551910.getPublicKey(privateBytes))}`;
     if (derivedPublic !== viewingKey.publicKey) {
       throw new ValidationError(
         "publicKey does not match privateKey",
@@ -25348,9 +25376,9 @@ function validateNEARViewingKey(viewingKey) {
 
 // src/chains/near/resolver.ts
 import { ed25519 as ed2551911 } from "@noble/curves/ed25519";
-import { bytesToHex as bytesToHex50, hexToBytes as hexToBytes33 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex49, hexToBytes as hexToBytes33 } from "@noble/hashes/utils";
 function nearSpendingPublicFromPrivate(spendingPrivateKey) {
-  return `0x${bytesToHex50(ed2551911.getPublicKey(hexToBytes33(spendingPrivateKey.slice(2))))}`;
+  return `0x${bytesToHex49(ed2551911.getPublicKey(hexToBytes33(spendingPrivateKey.slice(2))))}`;
 }
 function createNEARAnnouncementCache() {
   const entries = [];
@@ -25391,6 +25419,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);
@@ -25601,7 +25631,7 @@ var NEARStealthScanner = class {
             nearSpendingPublicFromPrivate(recipient.spendingPrivateKey)
           );
           if (isMatch) {
-            const stealthAddress = isImplicitAccount(announcement.stealthAddress) ? announcement.stealthAddress : bytesToHex50(hexToBytes33(stealthPublicKey.slice(2)));
+            const stealthAddress = isImplicitAccount(announcement.stealthAddress) ? announcement.stealthAddress : bytesToHex49(hexToBytes33(stealthPublicKey.slice(2)));
             let amount = metadata?.amount ?? 0n;
             if (amount === 0n && isImplicitAccount(stealthAddress)) {
               try {
@@ -26036,6 +26066,9 @@ var AllBackendsFailedError = class _AllBackendsFailedError extends Error {
     this.params = params;
     Object.setPrototypeOf(this, _AllBackendsFailedError.prototype);
   }
+  attemptedBackends;
+  errors;
+  params;
   name = "AllBackendsFailedError";
   /**
    * Get formatted error summary
@@ -26691,6 +26724,10 @@ var RateLimitExceededError = class extends Error {
     this.requestedTokens = requestedTokens;
     this.retryAfterMs = retryAfterMs;
   }
+  backend;
+  availableTokens;
+  requestedTokens;
+  retryAfterMs;
   name = "RateLimitExceededError";
 };
 var QueueFullError = class extends Error {
@@ -26702,6 +26739,9 @@ var QueueFullError = class extends Error {
     this.queueSize = queueSize;
     this.maxQueueSize = maxQueueSize;
   }
+  backend;
+  queueSize;
+  maxQueueSize;
   name = "QueueFullError";
 };
 var AcquireTimeoutError = class extends Error {
@@ -26710,6 +26750,8 @@ var AcquireTimeoutError = class extends Error {
     this.backend = backend;
     this.timeoutMs = timeoutMs;
   }
+  backend;
+  timeoutMs;
   name = "AcquireTimeoutError";
 };
 var RateLimiter = class {
@@ -27961,7 +28003,7 @@ function createPrivacyLogger(moduleName, config = {}) {
 }
 
 // src/privacy-backends/privacycash.ts
-import { randomBytes as randomBytes21, bytesToHex as bytesToHex51 } from "@noble/hashes/utils";
+import { randomBytes as randomBytes21, bytesToHex as bytesToHex50 } from "@noble/hashes/utils";
 var privacyCashLogger = createPrivacyLogger("PrivacyCash");
 var DEFAULT_ANONYMITY_SET = 50;
 var BASE_COST_LAMPORTS = BigInt(1e7);
@@ -27997,7 +28039,7 @@ import {
   InvalidAmountError,
   InvalidAddressError
 } from "@radr/shadowwire";
-import { bytesToHex as bytesToHex52 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex51 } from "@noble/hashes/utils";
 var SHADOWWIRE_TOKEN_MINTS = {
   SOL: "So11111111111111111111111111111111111111112",
   USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
@@ -28067,7 +28109,7 @@ import {
   PublicKey as PublicKey4,
   Transaction as Transaction3
 } from "@solana/web3.js";
-import { bytesToHex as bytesToHex53 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex52 } from "@noble/hashes/utils";
 var magicBlockLogger = createPrivacyLogger("MagicBlock");
 
 // src/privacy-backends/cspl-types.ts
@@ -28756,7 +28798,7 @@ var CSPLClient = class {
 
 // src/privacy-backends/private-swap.ts
 import { sha256 as sha25633 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex54 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex53 } from "@noble/hashes/utils";
 
 // src/privacy-backends/cspl-token.ts
 var CSPLTokenService = class {
@@ -31363,6 +31405,7 @@ var ProductionSafetyError = class extends Error {
     this.errors = errors;
     this.name = "ProductionSafetyError";
   }
+  errors;
 };
 function validateProductionConfig(config, options = {}) {
   const isProduction = isProductionEnvironment();
@@ -31461,7 +31504,7 @@ function createProductionConfig(defaults) {
 // src/sync/oblivious.ts
 import { sha256 as sha25634 } from "@noble/hashes/sha2";
 import { hmac as hmac5 } from "@noble/hashes/hmac";
-import { bytesToHex as bytesToHex55, hexToBytes as hexToBytes34, randomBytes as randomBytes22, utf8ToBytes as utf8ToBytes8 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex54, hexToBytes as hexToBytes34, randomBytes as randomBytes22, utf8ToBytes as utf8ToBytes8 } from "@noble/hashes/utils";
 var DEFAULT_SYNC_CONFIG = {
   maxBatchSize: 1e3,
   timeoutMs: 3e4,
@@ -31501,7 +31544,7 @@ function deriveObliviousNullifier(noteCommitment, spendingKey, syncRandomness) {
     message.set(syncRandomness.value, domain.length + commitmentBytes.length);
     const nullifierBytes = hmac5(sha25634, keyBytes, message);
     return {
-      nullifier: `0x${bytesToHex55(nullifierBytes)}`,
+      nullifier: `0x${bytesToHex54(nullifierBytes)}`,
       epoch: syncRandomness.epoch,
       chainId: "default"
       // Will be set by caller
@@ -31519,7 +31562,7 @@ function deriveTraditionalNullifier(noteCommitment, spendingKey) {
   );
   try {
     const nullifierBytes = hmac5(sha25634, keyBytes, commitmentBytes);
-    return `0x${bytesToHex55(nullifierBytes)}`;
+    return `0x${bytesToHex54(nullifierBytes)}`;
   } finally {
     secureWipe(keyBytes);
   }
@@ -31575,11 +31618,11 @@ function createTimeWindowedKey(masterViewingKey, startTime, endTime, epochDurati
   const keyHash = sha25634(derivedKey);
   secureWipe(keyBytes);
   return {
-    viewingKey: `0x${bytesToHex55(derivedKey)}`,
+    viewingKey: `0x${bytesToHex54(derivedKey)}`,
     windowStart: startTime,
     windowEnd: endTime,
     epochs,
-    hash: `0x${bytesToHex55(keyHash)}`
+    hash: `0x${bytesToHex54(keyHash)}`
   };
 }
 function isNoteInWindow(_note, _windowedKey) {
@@ -31602,10 +31645,12 @@ var ObliviousSyncError = class extends Error {
     this.context = context;
     this.name = "ObliviousSyncError";
   }
+  code;
+  context;
 };
 
 // src/sync/mock-provider.ts
-import { bytesToHex as bytesToHex56, randomBytes as randomBytes23 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex55, randomBytes as randomBytes23 } from "@noble/hashes/utils";
 var DEFAULT_MOCK_CONFIG = {
   chains: ["ethereum", "solana", "near"],
   latencyMs: 100,
@@ -31702,7 +31747,7 @@ var MockObliviousSyncProvider = class {
       merkleProofs,
       syncHeight: this.config.blockHeight,
       timestamp: Date.now(),
-      queryHash: `0x${bytesToHex56(randomBytes23(32))}`
+      queryHash: `0x${bytesToHex55(randomBytes23(32))}`
     };
   }
   async getCurrentHeight(chainId) {
@@ -31783,23 +31828,23 @@ var MockObliviousSyncProvider = class {
   generateMockNote(blockRange) {
     const blockNumber = blockRange.startBlock + BigInt(Math.floor(Math.random() * Number(blockRange.endBlock - blockRange.startBlock)));
     return {
-      commitment: `0x${bytesToHex56(randomBytes23(32))}`,
-      encryptedData: `0x${bytesToHex56(randomBytes23(128))}`,
+      commitment: `0x${bytesToHex55(randomBytes23(32))}`,
+      encryptedData: `0x${bytesToHex55(randomBytes23(128))}`,
       blockNumber,
-      txHash: `0x${bytesToHex56(randomBytes23(32))}`,
+      txHash: `0x${bytesToHex55(randomBytes23(32))}`,
       chainId: blockRange.chainId
     };
   }
   generateMockMerkleProof(leaf) {
     const siblings = [];
     for (let i = 0; i < 20; i++) {
-      siblings.push(`0x${bytesToHex56(randomBytes23(32))}`);
+      siblings.push(`0x${bytesToHex55(randomBytes23(32))}`);
     }
     return {
       leaf,
       siblings,
       index: BigInt(Math.floor(Math.random() * 1e6)),
-      root: `0x${bytesToHex56(randomBytes23(32))}`
+      root: `0x${bytesToHex55(randomBytes23(32))}`
     };
   }
 };