@sip-protocol/sdk 0.8.1 → 0.10.0

package/dist/{chunk-YWGJ77A2.mjs → chunk-PT2DNA7E.mjs}

@@ -34,7 +34,7 @@ import {
   validateEd25519StealthAddress,
   validateEd25519StealthMetaAddress,
   verifyOpening
-} from "./chunk-64AYA5F5.mjs";
+} from "./chunk-G3TBBG2K.mjs";
 import {
   ProofGenerationError
 } from "./chunk-HOR7PM3M.mjs";
@@ -51,7 +51,7 @@ import {
   SOLANA_RPC_ENDPOINTS,
   SUI_RPC_ENDPOINTS,
   ZCASH_RPC_CONFIG
-} from "./chunk-4GRJ5MAW.mjs";
+} from "./chunk-KXETSSKP.mjs";
 import {
   __export
 } from "./chunk-XGB3TDIC.mjs";
@@ -756,12 +756,12 @@ async function createShieldedIntent(params, options) {
         "Using placeholder signatures for proof generation - NOT cryptographically valid"
       );
     } else {
-      const { secp256k1: secp256k19 } = await import("@noble/curves/secp256k1");
-      const publicKey = secp256k19.getPublicKey(effectiveSenderSecret, true);
+      const { secp256k1: secp256k110 } = await import("@noble/curves/secp256k1");
+      const publicKey = secp256k110.getPublicKey(effectiveSenderSecret, true);
       const senderAddressBytes = sha2563(publicKey);
-      const ownershipSig = secp256k19.sign(senderAddressBytes, effectiveSenderSecret);
+      const ownershipSig = secp256k110.sign(senderAddressBytes, effectiveSenderSecret);
       effectiveOwnershipSig = ownershipSig.toCompactRawBytes();
-      const authSig = secp256k19.sign(intentHashBytes, effectiveSenderSecret);
+      const authSig = secp256k110.sign(intentHashBytes, effectiveSenderSecret);
       effectiveAuthSig = authSig.toCompactRawBytes();
     }
     const fundingResult = await proofProvider.generateFundingProof({
@@ -1230,11 +1230,11 @@ function deriveAptosStealthPrivateKey(stealthAddress, spendingPrivateKey, viewin
     aptosAddress
   };
 }
-function checkAptosStealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+function checkAptosStealthAddress(stealthAddress, viewingPrivateKey, spendingPublicKey) {
   return checkEd25519StealthAddress(
     stealthAddress,
-    spendingPrivateKey,
-    viewingPrivateKey
+    viewingPrivateKey,
+    spendingPublicKey
   );
 }
 var AptosStealthService = class {
@@ -1270,13 +1270,16 @@ var AptosStealthService = class {
   /**
    * Check if a stealth address belongs to this recipient
    *
+   * Canonical EIP-5564 view-only check: requires only the recipient's viewing
+   * private key plus their spending PUBLIC key (no spending private key needed).
+   *
    * @param stealthAddress - Stealth address to check
-   * @param spendingPrivateKey - Recipient's spending private key
    * @param viewingPrivateKey - Recipient's viewing private key
+   * @param spendingPublicKey - Recipient's spending public key (meta-address spendingKey)
    * @returns true if the address belongs to this recipient
    */
-  checkStealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
-    return checkAptosStealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey);
+  checkStealthAddress(stealthAddress, viewingPrivateKey, spendingPublicKey) {
+    return checkAptosStealthAddress(stealthAddress, viewingPrivateKey, spendingPublicKey);
   }
   /**
    * Validate an Aptos address format
@@ -1366,11 +1369,11 @@ function deriveSuiStealthPrivateKey(stealthAddress, spendingPrivateKey, viewingP
     suiAddress
   };
 }
-function checkSuiStealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+function checkSuiStealthAddress(stealthAddress, viewingPrivateKey, spendingPublicKey) {
   return checkEd25519StealthAddress(
     stealthAddress,
-    spendingPrivateKey,
-    viewingPrivateKey
+    viewingPrivateKey,
+    spendingPublicKey
   );
 }
 var SuiStealthService = class {
@@ -1406,13 +1409,16 @@ var SuiStealthService = class {
   /**
    * Check if a stealth address belongs to this recipient
    *
+   * Canonical EIP-5564 view-only check: requires only the recipient's viewing
+   * private key plus their spending PUBLIC key (no spending private key needed).
+   *
    * @param stealthAddress - Stealth address to check
-   * @param spendingPrivateKey - Recipient's spending private key
    * @param viewingPrivateKey - Recipient's viewing private key
+   * @param spendingPublicKey - Recipient's spending public key (meta-address spendingKey)
    * @returns true if the address belongs to this recipient
    */
-  checkStealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
-    return checkSuiStealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey);
+  checkStealthAddress(stealthAddress, viewingPrivateKey, spendingPublicKey) {
+    return checkSuiStealthAddress(stealthAddress, viewingPrivateKey, spendingPublicKey);
   }
   /**
    * Validate a Sui address format
@@ -2198,6 +2204,10 @@ import {
 } from "@solana/web3.js";
 import { bytesToHex as bytesToHex6 } from "@noble/hashes/utils";
 
+// src/adapters/gelato-relay.ts
+import { keccak_256 } from "@noble/hashes/sha3";
+import { bytesToHex as bytesToHex7 } from "@noble/hashes/utils";
+
 // src/sip.ts
 var SIP = class {
   config;
@@ -2672,10 +2682,10 @@ var SIP = class {
         "chain"
       );
     }
-    const { sendPrivateSPLTransfer: sendPrivateSPLTransfer2 } = await import("./solana-U3MEGU7W.mjs");
+    const { sendPrivateSPLTransfer: sendPrivateSPLTransfer2 } = await import("./solana-ZWNIQTSU.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-LHAAUC2T.mjs");
+    const { SOLANA_TOKEN_MINTS: SOLANA_TOKEN_MINTS3 } = await import("./constants-DCJYTIU3.mjs");
     let mint;
     if (params.token in SOLANA_TOKEN_MINTS3) {
       mint = new SolanaPublicKey(SOLANA_TOKEN_MINTS3[params.token]);
@@ -2728,7 +2738,7 @@ function createProductionSIP(config) {
 // src/cosmos/stealth.ts
 import { sha256 as sha2564 } from "@noble/hashes/sha256";
 import { ripemd160 } from "@noble/hashes/ripemd160";
-import { hexToBytes as hexToBytes5, bytesToHex as bytesToHex7 } from "@noble/hashes/utils";
+import { hexToBytes as hexToBytes5, bytesToHex as bytesToHex8 } from "@noble/hashes/utils";
 import { bech32 } from "@scure/base";
 var CHAIN_PREFIXES = {
   cosmos: "cosmos",
@@ -2810,8 +2820,8 @@ var CosmosStealthService = class {
       );
     }
     const metaAddress = {
-      spendingKey: `0x${bytesToHex7(spendingPubKey)}`,
-      viewingKey: `0x${bytesToHex7(viewingPubKey)}`,
+      spendingKey: `0x${bytesToHex8(spendingPubKey)}`,
+      viewingKey: `0x${bytesToHex8(viewingPubKey)}`,
       chain: "ethereum"
       // Use ethereum for secp256k1 generation
     };
@@ -3024,13 +3034,13 @@ function isValidCosmosAddress(address, expectedChain) {
 }
 
 // src/cosmos/ibc-stealth.ts
-import { hexToBytes as hexToBytes6, bytesToHex as bytesToHex8 } from "@noble/hashes/utils";
+import { hexToBytes as hexToBytes6, bytesToHex as bytesToHex9 } from "@noble/hashes/utils";
 import { secp256k1 } from "@noble/curves/secp256k1";
 import { sha256 as sha2565 } from "@noble/hashes/sha256";
 
 // src/proofs/mock.ts
 import { sha256 as sha2566 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex9, randomBytes as randomBytes4 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex10, randomBytes as randomBytes4 } from "@noble/hashes/utils";
 var log3 = createLogger("proofs/mock");
 var MOCK_PROOF_PREFIX = "0x4d4f434b";
 var MockProofProvider = class {
@@ -3211,11 +3221,11 @@ var MockProofProvider = class {
     combined.set(new TextEncoder().encode("MOCK"), 0);
     combined.set(hash2, 4);
     combined.set(random, 4 + hash2.length);
-    return `${MOCK_PROOF_PREFIX}${bytesToHex9(combined.slice(4))}`;
+    return `${MOCK_PROOF_PREFIX}${bytesToHex10(combined.slice(4))}`;
   }
   hashToHex(data) {
     const hash2 = sha2566(new TextEncoder().encode(data));
-    return `0x${bytesToHex9(hash2)}`;
+    return `0x${bytesToHex10(hash2)}`;
   }
 };
 
@@ -3500,7 +3510,7 @@ function hexToBytes7(hex) {
   }
   return bytes;
 }
-function bytesToHex10(bytes) {
+function bytesToHex11(bytes) {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 function isBrowser() {
@@ -3948,47 +3958,47 @@ var ComplianceProofProvider = class {
     }
   }
   async hashViewingKey(viewingKey) {
-    const { sha256: sha25634 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex55 } = await import("@noble/hashes/utils");
+    const { sha256: sha25635 } = await import("@noble/hashes/sha256");
+    const { bytesToHex: bytesToHex57 } = await import("@noble/hashes/utils");
     const keyString = typeof viewingKey === "string" ? viewingKey : JSON.stringify(viewingKey);
     const encoder = new TextEncoder();
     const keyBytes = encoder.encode(keyString);
-    return bytesToHex55(sha25634(keyBytes));
+    return bytesToHex57(sha25635(keyBytes));
   }
   async computeDecryptionCommitment(viewingKey, encryptedData) {
-    const { sha256: sha25634 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex55 } = await import("@noble/hashes/utils");
+    const { sha256: sha25635 } = await import("@noble/hashes/sha256");
+    const { bytesToHex: bytesToHex57 } = 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 bytesToHex55(sha25634(preimage));
+    return bytesToHex57(sha25635(preimage));
   }
   async computeAuditorHash(auditorPublicKey, transactionHash) {
-    const { sha256: sha25634 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex55 } = await import("@noble/hashes/utils");
+    const { sha256: sha25635 } = await import("@noble/hashes/sha256");
+    const { bytesToHex: bytesToHex57 } = 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 bytesToHex55(sha25634(preimage));
+    return bytesToHex57(sha25635(preimage));
   }
   async computeAddressCommitment(address, blinding) {
-    const { sha256: sha25634 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex55 } = await import("@noble/hashes/utils");
+    const { sha256: sha25635 } = await import("@noble/hashes/sha256");
+    const { bytesToHex: bytesToHex57 } = 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 bytesToHex55(sha25634(preimage));
+    return bytesToHex57(sha25635(preimage));
   }
   async computeNonMembershipProof(senderAddress, recipientAddress, _sanctionsListRoot) {
-    const { sha256: sha25634 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex55 } = await import("@noble/hashes/utils");
+    const { sha256: sha25635 } = await import("@noble/hashes/sha256");
+    const { bytesToHex: bytesToHex57 } = 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 bytesToHex55(sha25634(preimage));
+    return bytesToHex57(sha25635(preimage));
   }
   async computeBalanceCommitment(balance, blinding) {
-    const { sha256: sha25634 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex55 } = await import("@noble/hashes/utils");
+    const { sha256: sha25635 } = await import("@noble/hashes/sha256");
+    const { bytesToHex: bytesToHex57 } = await import("@noble/hashes/utils");
     const balanceBytes = new Uint8Array(8);
     let v = balance;
     for (let i = 7; i >= 0; i--) {
@@ -3996,11 +4006,11 @@ var ComplianceProofProvider = class {
       v = v >> 8n;
     }
     const preimage = new Uint8Array([...balanceBytes, ...blinding.slice(0, 32)]);
-    return bytesToHex55(sha25634(preimage));
+    return bytesToHex57(sha25635(preimage));
   }
   async generateComplianceProofBytes(type, publicInputs) {
-    const { sha256: sha25634 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex55 } = await import("@noble/hashes/utils");
+    const { sha256: sha25635 } = await import("@noble/hashes/sha256");
+    const { bytesToHex: bytesToHex57 } = 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", ""))));
@@ -4008,10 +4018,10 @@ var ComplianceProofProvider = class {
       ...encoder.encode(circuitId),
       ...inputBytes
     ]);
-    const hash2 = sha25634(preimage);
+    const hash2 = sha25635(preimage);
     let proofBytes = "";
     for (let i = 0; i < 8; i++) {
-      proofBytes += bytesToHex55(sha25634(new Uint8Array([...hash2, i])));
+      proofBytes += bytesToHex57(sha25635(new Uint8Array([...hash2, i])));
     }
     return proofBytes;
   }
@@ -4039,7 +4049,7 @@ var ComplianceProofProvider = class {
 };
 
 // src/proofs/aggregator.ts
-import { randomBytes as randomBytes5, bytesToHex as bytesToHex11 } from "@noble/hashes/utils";
+import { randomBytes as randomBytes5, bytesToHex as bytesToHex12 } from "@noble/hashes/utils";
 import {
   ProofAggregationStrategy as Strategy,
   ComposedProofStatus
@@ -4061,7 +4071,7 @@ var DEFAULT_AGGREGATOR_CONFIG = {
 };
 function generateId(prefix) {
   const bytes = randomBytes5(8);
-  return `${prefix}-${bytesToHex11(bytes)}`;
+  return `${prefix}-${bytesToHex12(bytes)}`;
 }
 function computeProofHash(proofs) {
   const data = proofs.map((p) => p.proof).join("");
@@ -4464,7 +4474,7 @@ var ProofAggregator = class {
     const proofBytes = randomBytes5(256);
     return {
       id: generateId(`recursive-${depth}`),
-      proof: `0x${bytesToHex11(proofBytes)}`,
+      proof: `0x${bytesToHex12(proofBytes)}`,
       publicInputs: combinedInputs.slice(0, 10),
       metadata: {
         system: targetSystem,
@@ -4679,7 +4689,7 @@ function createProofAggregator(config) {
 }
 
 // src/proofs/verifier.ts
-import { randomBytes as randomBytes6, bytesToHex as bytesToHex12 } from "@noble/hashes/utils";
+import { randomBytes as randomBytes6, bytesToHex as bytesToHex13 } from "@noble/hashes/utils";
 var DEFAULT_PIPELINE_CONFIG = {
   enableParallel: true,
   maxConcurrent: 4,
@@ -4693,7 +4703,7 @@ var DEFAULT_PIPELINE_CONFIG = {
   generateVerificationProof: false
 };
 function generateId2(prefix) {
-  return `${prefix}-${bytesToHex12(randomBytes6(8))}`;
+  return `${prefix}-${bytesToHex13(randomBytes6(8))}`;
 }
 function computeLinkHash(sourceProof, targetProof) {
   const combinedData = sourceProof.proof + targetProof.proof;
@@ -5673,7 +5683,7 @@ function createCrossSystemValidator(options) {
 }
 
 // src/proofs/orchestrator.ts
-import { randomBytes as randomBytes7, bytesToHex as bytesToHex13 } from "@noble/hashes/utils";
+import { randomBytes as randomBytes7, bytesToHex as bytesToHex14 } from "@noble/hashes/utils";
 import {
   ProofAggregationStrategy as Strategy2,
   ComposedProofStatus as ComposedProofStatus2
@@ -5732,7 +5742,7 @@ var BUILTIN_TEMPLATES = [
   }
 ];
 function generateId3(prefix) {
-  return `${prefix}-${bytesToHex13(randomBytes7(8))}`;
+  return `${prefix}-${bytesToHex14(randomBytes7(8))}`;
 }
 function delay2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -6289,7 +6299,7 @@ var IncompatibleSystemsError = class extends ProofCompositionError {
 
 // src/proofs/composer/base.ts
 import { randomBytes as randomBytes8 } from "@noble/hashes/utils";
-import { bytesToHex as bytesToHex14 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex15 } from "@noble/hashes/utils";
 import {
   ProofAggregationStrategy as Strategy3,
   ComposedProofStatus as ComposedProofStatus4,
@@ -6298,7 +6308,7 @@ import {
 } from "@sip-protocol/types";
 function generateId4(prefix) {
   const bytes = randomBytes8(8);
-  return `${prefix}-${bytesToHex14(bytes)}`;
+  return `${prefix}-${bytesToHex15(bytes)}`;
 }
 function computeProofHash2(proofs) {
   const data = proofs.map((p) => p.proof).join("");
@@ -6998,7 +7008,7 @@ var DEFAULT_CONVERSION_OPTIONS = {
 var CONVERTER_VERSION = "1.0.0";
 var SUPPORTED_NOIR_VERSIONS = ["0.30", "0.31", "0.32", "0.33", "0.34", "0.35", "1.0"];
 var SUPPORTED_BB_VERSIONS = ["0.47", "0.48", "0.49", "0.50", "0.51", "0.52", "0.53"];
-function bytesToHex15(bytes) {
+function bytesToHex16(bytes) {
   return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 function hexToBytes8(hex) {
@@ -7044,7 +7054,7 @@ var NoirProofConverter = class {
           nativeProof.proofData.length
         );
       }
-      const proofHex = bytesToHex15(nativeProof.proofData);
+      const proofHex = bytesToHex16(nativeProof.proofData);
       const publicInputsHex = nativeProof.publicInputs.map((input) => {
         if (input.startsWith("0x")) {
           return input;
@@ -7052,7 +7062,7 @@ var NoirProofConverter = class {
         const bigInt = BigInt(input);
         return "0x" + bigInt.toString(16).padStart(64, "0");
       });
-      const verificationKey = opts.includeVerificationKey && nativeProof.verificationKey ? typeof nativeProof.verificationKey === "string" ? nativeProof.verificationKey : bytesToHex15(nativeProof.verificationKey) : void 0;
+      const verificationKey = opts.includeVerificationKey && nativeProof.verificationKey ? typeof nativeProof.verificationKey === "string" ? nativeProof.verificationKey : bytesToHex16(nativeProof.verificationKey) : void 0;
       const metadata = {
         system: "noir",
         systemVersion: nativeProof.noirVersion || "unknown",
@@ -7285,7 +7295,7 @@ var CONVERTER_VERSION2 = "1.0.0";
 var SUPPORTED_HALO2_VERSIONS = ["0.2", "0.3", "1.0"];
 var MIN_K_VALUE = 4;
 var MAX_K_VALUE = 28;
-function bytesToHex16(bytes) {
+function bytesToHex17(bytes) {
   return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 function hexToBytes9(hex) {
@@ -7327,7 +7337,7 @@ var Halo2ProofConverter = class {
           nativeProof.proofData.length
         );
       }
-      const proofHex = bytesToHex16(nativeProof.proofData);
+      const proofHex = bytesToHex17(nativeProof.proofData);
       const publicInputsHex = nativeProof.publicInputs.map((input) => {
         if (input.startsWith("0x")) {
           return input;
@@ -7335,7 +7345,7 @@ var Halo2ProofConverter = class {
         const bigInt = BigInt(input);
         return "0x" + bigInt.toString(16).padStart(64, "0");
       });
-      const verificationKey = opts.includeVerificationKey && nativeProof.verificationKey ? typeof nativeProof.verificationKey === "string" ? nativeProof.verificationKey : bytesToHex16(nativeProof.verificationKey) : void 0;
+      const verificationKey = opts.includeVerificationKey && nativeProof.verificationKey ? typeof nativeProof.verificationKey === "string" ? nativeProof.verificationKey : bytesToHex17(nativeProof.verificationKey) : void 0;
       const circuitId = nativeProof.provingKeyCommitment ? `halo2-k${nativeProof.k || "unknown"}-${nativeProof.provingKeyCommitment.slice(0, 16)}` : `halo2-k${nativeProof.k || "unknown"}`;
       const metadata = {
         system: "halo2",
@@ -7572,7 +7582,7 @@ function createHalo2Converter() {
 var CONVERTER_VERSION3 = "1.0.0";
 var SUPPORTED_KIMCHI_VERSIONS = ["0.15", "0.16", "0.17", "0.18", "1.0", "1.1", "1.2"];
 var PALLAS_MODULUS2 = BigInt("0x40000000000000000000000000000000224698fc094cf91b992d30ed00000001");
-function bytesToHex17(bytes) {
+function bytesToHex18(bytes) {
   return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 function hexToBytes10(hex) {
@@ -7622,7 +7632,7 @@ var KimchiProofConverter = class {
           nativeProof.proofData.length
         );
       }
-      const proofHex = bytesToHex17(nativeProof.proofData);
+      const proofHex = bytesToHex18(nativeProof.proofData);
       const publicInputsHex = nativeProof.publicInputs.map((input) => {
         if (input.startsWith("0x")) {
           return input;
@@ -7630,7 +7640,7 @@ var KimchiProofConverter = class {
         const bigInt = BigInt(input);
         return "0x" + bigInt.toString(16).padStart(64, "0");
       });
-      const verificationKey = opts.includeVerificationKey && nativeProof.verificationKey ? typeof nativeProof.verificationKey === "string" ? nativeProof.verificationKey : bytesToHex17(nativeProof.verificationKey) : void 0;
+      const verificationKey = opts.includeVerificationKey && nativeProof.verificationKey ? typeof nativeProof.verificationKey === "string" ? nativeProof.verificationKey : bytesToHex18(nativeProof.verificationKey) : void 0;
       const circuitId = nativeProof.verifierIndexCommitment ? `kimchi-${nativeProof.verifierIndexCommitment.slice(0, 16)}` : "kimchi-unknown";
       const metadata = {
         system: "kimchi",
@@ -8013,7 +8023,7 @@ var DEFAULT_WARMING_CONFIG = {
 
 // src/proofs/cache/key-generator.ts
 import { sha256 as sha2567 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex18 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex19 } from "@noble/hashes/utils";
 var KEY_SEPARATOR = ":";
 var KEY_PREFIX = "sip-proof";
 var KEY_VERSION = "v1";
@@ -8035,7 +8045,7 @@ function canonicalize(value) {
     return value.toString();
   }
   if (value instanceof Uint8Array) {
-    return `bytes:${bytesToHex18(value)}`;
+    return `bytes:${bytesToHex19(value)}`;
   }
   if (Array.isArray(value)) {
     return `[${value.map(canonicalize).join(",")}]`;
@@ -8098,7 +8108,7 @@ var CacheKeyGenerator = class {
   hashInputs(inputs) {
     const canonical = canonicalize(inputs);
     const hash2 = sha2567(new TextEncoder().encode(canonical));
-    return bytesToHex18(hash2);
+    return bytesToHex19(hash2);
   }
   /**
    * Generate a cache key from raw inputs
@@ -9547,11 +9557,11 @@ var CHAIN_NUMERIC_IDS = {
 // src/oracle/verification.ts
 import { ed25519 } from "@noble/curves/ed25519";
 import { sha256 as sha2569 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex20, hexToBytes as hexToBytes12 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex21, hexToBytes as hexToBytes12 } from "@noble/hashes/utils";
 
 // src/oracle/serialization.ts
 import { sha256 as sha2568 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex19, hexToBytes as hexToBytes11, utf8ToBytes as utf8ToBytes2 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex20, hexToBytes as hexToBytes11, utf8ToBytes as utf8ToBytes2 } from "@noble/hashes/utils";
 function serializeAttestationMessage(message) {
   const buffer = new Uint8Array(197);
   const view = new DataView(buffer.buffer);
@@ -9594,19 +9604,19 @@ function deserializeAttestationMessage(bytes) {
   const version = bytes[offset++];
   const chainId = view.getUint32(offset, false);
   offset += 4;
-  const intentHash = `0x${bytesToHex19(bytes.slice(offset, offset + 32))}`;
+  const intentHash = `0x${bytesToHex20(bytes.slice(offset, offset + 32))}`;
   offset += 32;
-  const recipient = `0x${bytesToHex19(bytes.slice(offset, offset + 32))}`;
+  const recipient = `0x${bytesToHex20(bytes.slice(offset, offset + 32))}`;
   offset += 32;
   const amount = bytesToBigint(bytes.slice(offset, offset + 16));
   offset += 16;
-  const assetId = `0x${bytesToHex19(bytes.slice(offset, offset + 32))}`;
+  const assetId = `0x${bytesToHex20(bytes.slice(offset, offset + 32))}`;
   offset += 32;
-  const txHash = `0x${bytesToHex19(bytes.slice(offset, offset + 32))}`;
+  const txHash = `0x${bytesToHex20(bytes.slice(offset, offset + 32))}`;
   offset += 32;
   const blockNumber = view.getBigUint64(offset, false);
   offset += 8;
-  const blockHash = `0x${bytesToHex19(bytes.slice(offset, offset + 32))}`;
+  const blockHash = `0x${bytesToHex20(bytes.slice(offset, offset + 32))}`;
   offset += 32;
   const timestamp = Number(view.getBigUint64(offset, false));
   return {
@@ -9674,7 +9684,7 @@ function bytesToBigint(bytes) {
 function deriveOracleId(publicKey) {
   const keyBytes = typeof publicKey === "string" ? hexToBytes12(publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey) : publicKey;
   const hash2 = sha2569(keyBytes);
-  return `0x${bytesToHex20(hash2)}`;
+  return `0x${bytesToHex21(hash2)}`;
 }
 function verifyAttestation(attestation, registry) {
   const { message, signatures } = attestation;
@@ -9749,7 +9759,7 @@ function signAttestationMessage(messageHash, privateKey) {
   const oracleId = deriveOracleId(publicKey);
   return {
     oracleId,
-    signature: `0x${bytesToHex20(signature)}`
+    signature: `0x${bytesToHex21(signature)}`
   };
 }
 function createOracleRegistry(config = {}) {
@@ -9999,7 +10009,7 @@ import { ReportStatus as ReportStatus2 } from "@sip-protocol/types";
 import {
   IntentStatus as IntentStatus3
 } from "@sip-protocol/types";
-import { bytesToHex as bytesToHex21, randomBytes as randomBytes9 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex22, randomBytes as randomBytes9 } from "@noble/hashes/utils";
 var MockSolver = class {
   info;
   capabilities;
@@ -10081,7 +10091,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-${bytesToHex21(randomBytes9(8))}`;
+    const quoteId = `quote-${bytesToHex22(randomBytes9(8))}`;
     const now = Math.floor(Date.now() / 1e3);
     const quote = {
       quoteId,
@@ -10092,7 +10102,7 @@ var MockSolver = class {
       expiry: now + 60,
       // Quote valid for 1 minute
       fee: feeAmount,
-      signature: `0x${bytesToHex21(randomBytes9(64))}`,
+      signature: `0x${bytesToHex22(randomBytes9(64))}`,
       // Mock signature
       validUntil: now + 60,
       estimatedGas: 200000n
@@ -10129,7 +10139,7 @@ var MockSolver = class {
         error: status.error
       };
     }
-    const txHash = `0x${bytesToHex21(randomBytes9(32))}`;
+    const txHash = `0x${bytesToHex22(randomBytes9(32))}`;
     status.status = "completed";
     status.txHash = txHash;
     return {
@@ -10139,10 +10149,10 @@ var MockSolver = class {
       txHash: intent.privacyLevel === "transparent" ? txHash : void 0,
       fulfillmentProof: {
         type: "fulfillment",
-        proof: `0x${bytesToHex21(randomBytes9(128))}`,
+        proof: `0x${bytesToHex22(randomBytes9(128))}`,
         publicInputs: [
-          `0x${bytesToHex21(new TextEncoder().encode(intent.intentId))}`,
-          `0x${bytesToHex21(new TextEncoder().encode(quote.quoteId))}`
+          `0x${bytesToHex22(new TextEncoder().encode(intent.intentId))}`,
+          `0x${bytesToHex22(new TextEncoder().encode(quote.quoteId))}`
         ]
       },
       fulfilledAt: Math.floor(Date.now() / 1e3)
@@ -11710,7 +11720,7 @@ function createZcashNativeBackend(config) {
 
 // src/settlement/backends/direct-chain.ts
 import { PrivacyLevel as PrivacyLevel5 } from "@sip-protocol/types";
-import { randomBytes as randomBytes10, bytesToHex as bytesToHex22 } from "@noble/hashes/utils";
+import { randomBytes as randomBytes10, bytesToHex as bytesToHex23 } from "@noble/hashes/utils";
 var DEFAULT_GAS_FEES = {
   ethereum: 21000n * 50n * 1000000000n,
   // 21k gas * 50 gwei = 0.00105 ETH
@@ -13043,7 +13053,7 @@ import { ZcashErrorCode as ZcashErrorCode3 } from "@sip-protocol/types";
 // src/bitcoin/taproot.ts
 import { secp256k1 as secp256k12, schnorr } from "@noble/curves/secp256k1";
 import { sha256 as sha25610 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex23, hexToBytes as hexToBytes13 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex24, hexToBytes as hexToBytes13 } from "@noble/hashes/utils";
 var BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
 var BECH32_GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
 function taggedHash(tag, data) {
@@ -13098,16 +13108,16 @@ function computeTweakedKey(internalKey, merkleRoot) {
   }
   const tweakData = merkleRoot ? new Uint8Array([...internalKey, ...merkleRoot]) : internalKey;
   const tweak = taggedHash("TapTweak", tweakData);
-  const tweakScalar = BigInt("0x" + bytesToHex23(tweak)) % secp256k12.CURVE.n;
+  const tweakScalar = BigInt("0x" + bytesToHex24(tweak)) % secp256k12.CURVE.n;
   const internalPoint = secp256k12.ProjectivePoint.fromHex(
-    "02" + bytesToHex23(internalKey)
+    "02" + bytesToHex24(internalKey)
   );
   const tweakPoint = secp256k12.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" + bytesToHex23(yCoord));
+  const yBigInt = BigInt("0x" + bytesToHex24(yCoord));
   const parity = Number(yBigInt & 1n);
   return {
     tweakedKey: xOnly,
@@ -13137,9 +13147,9 @@ function createTaprootOutput(internalKey, scripts) {
   }
   const { tweakedKey, parity } = computeTweakedKey(internalKey, merkleRoot);
   return {
-    tweakedKey: `0x${bytesToHex23(tweakedKey)}`,
-    internalKey: `0x${bytesToHex23(internalKey)}`,
-    merkleRoot: merkleRoot ? `0x${bytesToHex23(merkleRoot)}` : void 0,
+    tweakedKey: `0x${bytesToHex24(tweakedKey)}`,
+    internalKey: `0x${bytesToHex24(internalKey)}`,
+    merkleRoot: merkleRoot ? `0x${bytesToHex24(merkleRoot)}` : void 0,
     parity
   };
 }
@@ -13305,7 +13315,7 @@ function schnorrSignHex(message, privateKey, auxRand) {
   const privateKeyBytes = hexToBytes13(privateKey.slice(2));
   const auxRandBytes = auxRand ? hexToBytes13(auxRand.slice(2)) : void 0;
   const signature = schnorrSign(messageBytes, privateKeyBytes, auxRandBytes);
-  return `0x${bytesToHex23(signature)}`;
+  return `0x${bytesToHex24(signature)}`;
 }
 function schnorrVerifyHex(signature, message, publicKey) {
   if (!isValidHex(signature)) {
@@ -13326,7 +13336,7 @@ function schnorrVerifyHex(signature, message, publicKey) {
 // src/bitcoin/silent-payments.ts
 import { secp256k1 as secp256k13 } from "@noble/curves/secp256k1";
 import { sha256 as sha25611 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex24, hexToBytes as hexToBytes14 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex25, hexToBytes as hexToBytes14 } from "@noble/hashes/utils";
 
 // src/payment/payment.ts
 import {
@@ -13335,7 +13345,7 @@ import {
   PaymentStatus
 } from "@sip-protocol/types";
 import { sha256 as sha25612 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex25, hexToBytes as hexToBytes15, randomBytes as randomBytes11 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex26, hexToBytes as hexToBytes15, randomBytes as randomBytes11 } from "@noble/hashes/utils";
 import { xchacha20poly1305 as xchacha20poly13052 } from "@noble/ciphers/chacha.js";
 import { hkdf as hkdf2 } from "@noble/hashes/hkdf";
 
@@ -13832,7 +13842,7 @@ async function createShieldedPayment(params, options) {
   if (viewingKey) {
     const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
     const keyBytes = hexToBytes15(keyHex);
-    viewingKeyHash = `0x${bytesToHex25(sha25612(keyBytes))}`;
+    viewingKeyHash = `0x${bytesToHex26(sha25612(keyBytes))}`;
   }
   const privacyConfig = getPrivacyConfig(
     privacy,
@@ -13909,7 +13919,7 @@ function encryptMemo(memo, viewingKey) {
     const result = new Uint8Array(nonce.length + ciphertext.length);
     result.set(nonce);
     result.set(ciphertext, nonce.length);
-    return `0x${bytesToHex25(result)}`;
+    return `0x${bytesToHex26(result)}`;
   } finally {
     secureWipe(keyBytes);
     secureWipe(encKey);
@@ -13974,7 +13984,7 @@ import {
 } from "@sip-protocol/types";
 import { secp256k1 as secp256k14 } from "@noble/curves/secp256k1";
 import { sha256 as sha25613 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex26, hexToBytes as hexToBytes16, randomBytes as randomBytes12 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex27, hexToBytes as hexToBytes16, randomBytes as randomBytes12 } from "@noble/hashes/utils";
 var DEFAULT_PROPOSAL_TTL = 7 * 24 * 60 * 60;
 var Treasury = class _Treasury {
   config;
@@ -14466,11 +14476,11 @@ var Treasury = class _Treasury {
 };
 function generateTreasuryId() {
   const bytes = randomBytes12(16);
-  return `treasury_${bytesToHex26(bytes)}`;
+  return `treasury_${bytesToHex27(bytes)}`;
 }
 function generateProposalId() {
   const bytes = randomBytes12(16);
-  return `prop_${bytesToHex26(bytes)}`;
+  return `prop_${bytesToHex27(bytes)}`;
 }
 function computeProposalHash(proposal) {
   const data = JSON.stringify({
@@ -14660,7 +14670,7 @@ function validateBatchProposalParams(params, config) {
 import {
   ReportStatus
 } from "@sip-protocol/types";
-import { bytesToHex as bytesToHex27, randomBytes as randomBytes13 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex28, randomBytes as randomBytes13 } from "@noble/hashes/utils";
 var DEFAULTS2 = {
   riskThreshold: 70,
   highValueThreshold: 10000000000n,
@@ -15407,7 +15417,7 @@ var ComplianceManager = class _ComplianceManager {
   }
 };
 function generateId5(prefix) {
-  return `${prefix}_${bytesToHex27(randomBytes13(12))}`;
+  return `${prefix}_${bytesToHex28(randomBytes13(12))}`;
 }
 function validateRegisterAuditorParams(params) {
   if (!params.organization?.trim()) {
@@ -15496,7 +15506,7 @@ function validateReportParams(params) {
 
 // src/compliance/reports.ts
 import { sha256 as sha25614 } from "@noble/hashes/sha256";
-import { hexToBytes as hexToBytes17, bytesToHex as bytesToHex28 } from "@noble/hashes/utils";
+import { hexToBytes as hexToBytes17, bytesToHex as bytesToHex29 } from "@noble/hashes/utils";
 
 // src/compliance/pdf.ts
 function generatePdfReport(report, options = {}) {
@@ -15802,7 +15812,7 @@ var ComplianceReporter = class {
       return {
         key: `0x${keyHex}`,
         path: "m/0",
-        hash: `0x${bytesToHex28(hashBytes)}`
+        hash: `0x${bytesToHex29(hashBytes)}`
       };
     }
     return viewingKey;
@@ -16184,7 +16194,7 @@ var ComplianceReporter = class {
 
 // src/compliance/conditional.ts
 import { sha256 as sha25615 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex29, hexToBytes as hexToBytes18, randomBytes as randomBytes14 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex30, hexToBytes as hexToBytes18, randomBytes as randomBytes14 } from "@noble/hashes/utils";
 import { xchacha20poly1305 as xchacha20poly13053 } from "@noble/ciphers/chacha.js";
 var ConditionalDisclosure = class {
   /**
@@ -16260,10 +16270,10 @@ var ConditionalDisclosure = class {
       ]);
       const commitmentHash = sha25615(commitmentData);
       return {
-        encryptedKey: "0x" + bytesToHex29(encryptedKey),
-        nonce: "0x" + bytesToHex29(nonce),
+        encryptedKey: "0x" + bytesToHex30(encryptedKey),
+        nonce: "0x" + bytesToHex30(nonce),
         revealAfter: revealAfterSeconds,
-        verificationCommitment: "0x" + bytesToHex29(commitmentHash),
+        verificationCommitment: "0x" + bytesToHex30(commitmentHash),
         encryptionCommitment: params.commitment,
         type
       };
@@ -16344,7 +16354,7 @@ var ConditionalDisclosure = class {
       const encryptedData = hexToBytes18(timeLock.encryptedKey.slice(2));
       const cipher = xchacha20poly13053(encryptionKey, nonce);
       const decryptedBytes = cipher.decrypt(encryptedData);
-      const viewingKey = "0x" + bytesToHex29(decryptedBytes);
+      const viewingKey = "0x" + bytesToHex30(decryptedBytes);
       return {
         unlocked: true,
         viewingKey
@@ -16432,12 +16442,12 @@ var ConditionalDisclosure = class {
 // src/compliance/conditional-threshold.ts
 import { secp256k1 as secp256k15 } from "@noble/curves/secp256k1";
 import { sha256 as sha25616 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex30, hexToBytes as hexToBytes19 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex31, hexToBytes as hexToBytes19 } from "@noble/hashes/utils";
 var CURVE_ORDER = secp256k15.CURVE.n;
 
 // src/compliance/threshold.ts
 import { sha256 as sha25617 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex31, hexToBytes as hexToBytes20, randomBytes as randomBytes15 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex32, hexToBytes as hexToBytes20, randomBytes as randomBytes15 } from "@noble/hashes/utils";
 var FIELD_PRIME = 2n ** 256n - 189n;
 var ThresholdViewingKey = class {
   /**
@@ -16680,7 +16690,7 @@ var ThresholdViewingKey = class {
   static createCommitment(secret, coefficients) {
     const data = [secret, ...coefficients].map((c) => c.toString(16).padStart(64, "0")).join("");
     const hash2 = sha25617(hexToBytes20(data));
-    return bytesToHex31(hash2);
+    return bytesToHex32(hash2);
   }
   /**
    * Encode share as string: "x:y:len:commitment"
@@ -16806,7 +16816,7 @@ var ThresholdViewingKey = class {
 import { sha256 as sha25618 } from "@noble/hashes/sha256";
 import { sha512 as sha5122 } from "@noble/hashes/sha512";
 import { hmac as hmac2 } from "@noble/hashes/hmac";
-import { bytesToHex as bytesToHex32, utf8ToBytes as utf8ToBytes4 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex33, utf8ToBytes as utf8ToBytes4 } from "@noble/hashes/utils";
 var AuditorType = /* @__PURE__ */ ((AuditorType2) => {
   AuditorType2[AuditorType2["PRIMARY"] = 0] = "PRIMARY";
   AuditorType2[AuditorType2["REGULATORY"] = 1] = "REGULATORY";
@@ -16916,9 +16926,9 @@ var AuditorKeyDerivation = class {
         currentKey = new Uint8Array(derived.key);
         chainCode = new Uint8Array(derived.chainCode);
       }
-      const keyHex = `0x${bytesToHex32(currentKey)}`;
+      const keyHex = `0x${bytesToHex33(currentKey)}`;
       const hashBytes = sha25618(currentKey);
-      const hash2 = `0x${bytesToHex32(hashBytes)}`;
+      const hash2 = `0x${bytesToHex33(hashBytes)}`;
       const viewingKey = {
         key: keyHex,
         path,
@@ -17002,9 +17012,9 @@ var AuditorKeyDerivation = class {
       for (const auditorType of uniqueTypes) {
         const derived = this.deriveChildKey(commonKey, commonChainCode, auditorType);
         try {
-          const keyHex = `0x${bytesToHex32(derived.key)}`;
+          const keyHex = `0x${bytesToHex33(derived.key)}`;
           const hashBytes = sha25618(derived.key);
-          const hash2 = `0x${bytesToHex32(hashBytes)}`;
+          const hash2 = `0x${bytesToHex33(hashBytes)}`;
           const path = this.derivePath(auditorType, account);
           const viewingKey = {
             key: keyHex,
@@ -17128,7 +17138,7 @@ var AuditorKeyDerivation = class {
 import { sha256 as sha25619 } from "@noble/hashes/sha256";
 import { hmac as hmac3 } from "@noble/hashes/hmac";
 import { sha512 as sha5123 } from "@noble/hashes/sha512";
-import { bytesToHex as bytesToHex33, hexToBytes as hexToBytes22, utf8ToBytes as utf8ToBytes5 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex34, hexToBytes as hexToBytes22, utf8ToBytes as utf8ToBytes5 } from "@noble/hashes/utils";
 var AttestationSchema = /* @__PURE__ */ ((AttestationSchema2) => {
   AttestationSchema2["RANGE_KYC_V1"] = "range-kyc-v1";
   AttestationSchema2["RANGE_ACCREDITED_INVESTOR"] = "range-accredited-investor";
@@ -17369,9 +17379,9 @@ var AttestationGatedDisclosure = class {
     const derived = hmac3(sha5123, masterKeyBytes, derivationData);
     const keyBytes = derived.slice(0, 32);
     try {
-      const key = `0x${bytesToHex33(keyBytes)}`;
+      const key = `0x${bytesToHex34(keyBytes)}`;
       const hashBytes = sha25619(keyBytes);
-      const hash2 = `0x${bytesToHex33(hashBytes)}`;
+      const hash2 = `0x${bytesToHex34(hashBytes)}`;
       return {
         key,
         path: `${this.config.masterViewingKey.path}/sas/${attestation.uid.slice(0, 8)}`,
@@ -17462,7 +17472,7 @@ async function verifyAttestationSignature(attestation, options = {}) {
   }
   const signedMessage = constructAttestationMessage(attestation);
   try {
-    const { ed25519: ed2551910 } = await import("@noble/curves/ed25519");
+    const { ed25519: ed2551912 } = await import("@noble/curves/ed25519");
     const signatureBytes = hexToBytes22(
       attestation.signature.startsWith("0x") ? attestation.signature.slice(2) : attestation.signature
     );
@@ -17470,7 +17480,7 @@ async function verifyAttestationSignature(attestation, options = {}) {
       issuerPublicKey.startsWith("0x") ? issuerPublicKey.slice(2) : issuerPublicKey
     );
     const messageBytes = utf8ToBytes5(signedMessage);
-    return ed2551910.verify(signatureBytes, messageBytes, publicKeyBytes);
+    return ed2551912.verify(signatureBytes, messageBytes, publicKeyBytes);
   } catch (error) {
     console.warn(`[Range SAS] Signature verification error: ${error}`);
     return false;
@@ -17626,10 +17636,10 @@ async function fetchWalletAttestations(walletAddress, options = {}) {
 
 // src/compliance/fireblocks.ts
 import { sha256 as sha25620 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex34, hexToBytes as hexToBytes23 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex35, hexToBytes as hexToBytes23 } from "@noble/hashes/utils";
 
 // src/auction/sealed-bid.ts
-import { randomBytes as randomBytes16, bytesToHex as bytesToHex35 } from "@noble/hashes/utils";
+import { randomBytes as randomBytes16, bytesToHex as bytesToHex36 } from "@noble/hashes/utils";
 var SealedBidAuction = class {
   /**
    * Create a sealed bid for an auction
@@ -17850,7 +17860,7 @@ var SealedBidAuction = class {
    * ```
    */
   revealBid(bid, amount, salt) {
-    const saltHex = `0x${bytesToHex35(salt)}`;
+    const saltHex = `0x${bytesToHex36(salt)}`;
     const isValid = this.verifyBid({
       commitment: bid.commitment,
       amount,
@@ -18337,7 +18347,7 @@ function createSealedBidAuction() {
 // src/governance/private-vote.ts
 import { sha256 as sha25621 } from "@noble/hashes/sha256";
 import { hkdf as hkdf3 } from "@noble/hashes/hkdf";
-import { bytesToHex as bytesToHex36, hexToBytes as hexToBytes24, randomBytes as randomBytes17, utf8ToBytes as utf8ToBytes6 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex37, hexToBytes as hexToBytes24, randomBytes as randomBytes17, utf8ToBytes as utf8ToBytes6 } from "@noble/hashes/utils";
 import { xchacha20poly1305 as xchacha20poly13054 } from "@noble/ciphers/chacha.js";
 var VOTE_ENCRYPTION_DOMAIN = "SIP-PRIVATE-VOTE-ENCRYPTION-V1";
 var NONCE_SIZE2 = 24;
@@ -18387,9 +18397,9 @@ var PrivateVoting = class {
       const ciphertext = cipher.encrypt(plaintext);
       const keyHash = sha25621(hexToBytes24(encryptionKey.slice(2)));
       return {
-        ciphertext: `0x${bytesToHex36(ciphertext)}`,
-        nonce: `0x${bytesToHex36(nonce)}`,
-        encryptionKeyHash: `0x${bytesToHex36(keyHash)}`,
+        ciphertext: `0x${bytesToHex37(ciphertext)}`,
+        nonce: `0x${bytesToHex37(nonce)}`,
+        encryptionKeyHash: `0x${bytesToHex37(keyHash)}`,
         proposalId,
         voter,
         timestamp: voteData.timestamp
@@ -18436,7 +18446,7 @@ var PrivateVoting = class {
     const derivedKey = this.deriveEncryptionKey(decryptionKey, vote.proposalId);
     try {
       const keyHash = sha25621(hexToBytes24(decryptionKey.slice(2)));
-      const expectedKeyHash = `0x${bytesToHex36(keyHash)}`;
+      const expectedKeyHash = `0x${bytesToHex37(keyHash)}`;
       if (vote.encryptionKeyHash !== expectedKeyHash) {
         throw new CryptoError(
           "Decryption key hash mismatch - this key cannot decrypt this vote",
@@ -18698,8 +18708,8 @@ var PrivateVoting = class {
         const blindingBytes = hexToBytes24(blinding.slice(2));
         const ciphertext = cipher.encrypt(blindingBytes);
         encryptedBlindings[choice] = {
-          ciphertext: `0x${bytesToHex36(ciphertext)}`,
-          nonce: `0x${bytesToHex36(nonce)}`
+          ciphertext: `0x${bytesToHex37(ciphertext)}`,
+          nonce: `0x${bytesToHex37(nonce)}`
         };
       } finally {
         secureWipe(derivedKey);
@@ -18807,7 +18817,7 @@ var PrivateVoting = class {
           reconstructedKey[j] ^= shareBytes[j];
         }
       }
-      const reconstructedKeyHex = `0x${bytesToHex36(reconstructedKey)}`;
+      const reconstructedKeyHex = `0x${bytesToHex37(reconstructedKey)}`;
       const results = {};
       for (const [choice, commitmentPoint] of Object.entries(tally.tallies)) {
         const encBlinding = tally.encryptedBlindings[choice];
@@ -18828,7 +18838,7 @@ var PrivateVoting = class {
           const ciphertextBytes = hexToBytes24(encBlinding.ciphertext.slice(2));
           const cipher = xchacha20poly13054(derivedKey, nonceBytes);
           const blindingBytes = cipher.decrypt(ciphertextBytes);
-          blindingFactor = `0x${bytesToHex36(blindingBytes)}`;
+          blindingFactor = `0x${bytesToHex37(blindingBytes)}`;
         } catch (e) {
           throw new CryptoError(
             "failed to decrypt blinding factor",
@@ -19049,8 +19059,9 @@ function createPrivateVoting() {
 
 // src/nft/private-nft.ts
 import { sha256 as sha25622 } from "@noble/hashes/sha256";
+import { ed25519 as ed255192 } from "@noble/curves/ed25519";
 import { secp256k1 as secp256k16 } from "@noble/curves/secp256k1";
-import { bytesToHex as bytesToHex37, hexToBytes as hexToBytes25 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex38, hexToBytes as hexToBytes25 } from "@noble/hashes/utils";
 var PrivateNFT = class {
   /**
    * Create a private ownership record for an NFT
@@ -19141,9 +19152,9 @@ var PrivateNFT = class {
       const signature = secp256k16.sign(messageHash, privateKeyBytes);
       const zkProof = {
         type: "ownership",
-        proof: `0x${bytesToHex37(signature.toCompactRawBytes())}`,
+        proof: `0x${bytesToHex38(signature.toCompactRawBytes())}`,
         publicInputs: [
-          `0x${bytesToHex37(messageHash)}`
+          `0x${bytesToHex38(messageHash)}`
         ]
       };
       const stealthHashBytes = sha25622(hexToBytes25(ownership.ownerStealth.address.slice(2)));
@@ -19152,7 +19163,7 @@ var PrivateNFT = class {
         tokenId: ownership.tokenId,
         challenge,
         proof: zkProof,
-        stealthHash: `0x${bytesToHex37(stealthHashBytes)}`,
+        stealthHash: `0x${bytesToHex38(stealthHashBytes)}`,
         timestamp: Date.now()
       };
     } catch (e) {
@@ -19298,7 +19309,7 @@ var PrivateNFT = class {
       nftContract: nft.nftContract,
       tokenId: nft.tokenId,
       newOwnerStealth,
-      previousOwnerHash: `0x${bytesToHex37(previousOwnerHashBytes)}`,
+      previousOwnerHash: `0x${bytesToHex38(previousOwnerHashBytes)}`,
       chain: nft.chain,
       timestamp: Date.now()
     };
@@ -19365,8 +19376,9 @@ var PrivateNFT = class {
       );
     }
     const ownedNFTs = [];
-    const scanKeyHex = `0x${bytesToHex37(scanKey)}`;
-    const viewingKeyHex = `0x${bytesToHex37(viewingKey)}`;
+    const viewingKeyHex = `0x${bytesToHex38(viewingKey)}`;
+    const ed25519SpendingPubHex = `0x${bytesToHex38(ed255192.getPublicKey(scanKey))}`;
+    const secp256k1SpendingPubHex = `0x${bytesToHex38(secp256k16.getPublicKey(scanKey, true))}`;
     for (const transfer of transfers) {
       try {
         if (!transfer || typeof transfer !== "object") {
@@ -19379,14 +19391,14 @@ var PrivateNFT = class {
         if (isEd25519Chain(transfer.chain)) {
           isOwned = checkEd25519StealthAddress(
             transfer.newOwnerStealth,
-            scanKeyHex,
-            viewingKeyHex
+            viewingKeyHex,
+            ed25519SpendingPubHex
           );
         } else {
           isOwned = checkStealthAddress(
             transfer.newOwnerStealth,
-            scanKeyHex,
-            viewingKeyHex
+            viewingKeyHex,
+            secp256k1SpendingPubHex
           );
         }
         if (isOwned) {
@@ -20804,7 +20816,7 @@ function createMockSolanaAdapter(config = {}) {
 
 // src/wallet/solana/privacy-adapter.ts
 import { sha256 as sha25623 } from "@noble/hashes/sha2";
-import { ed25519 as ed255192 } from "@noble/curves/ed25519";
+import { ed25519 as ed255193 } from "@noble/curves/ed25519";
 var ED25519_ORDER = BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed");
 
 // src/wallet/ethereum/adapter.ts
@@ -21379,9 +21391,12 @@ function createEthereumAdapter(config) {
 }
 
 // src/wallet/ethereum/privacy-adapter.ts
-import { sha256 as sha25624 } from "@noble/hashes/sha2";
+import { sha256 as sha25625 } from "@noble/hashes/sha2";
+import { secp256k1 as secp256k18 } from "@noble/curves/secp256k1";
+import { keccak_256 as keccak_2562 } from "@noble/hashes/sha3";
+
+// src/chains/ethereum/stealth.ts
 import { secp256k1 as secp256k17 } from "@noble/curves/secp256k1";
-import { keccak_256 } from "@noble/hashes/sha3";
 
 // src/chains/ethereum/constants.ts
 function getEnvVar(name, defaultValue) {
@@ -21899,9 +21914,9 @@ import { WalletErrorCode as WalletErrorCode14 } from "@sip-protocol/types";
 import { WalletErrorCode as WalletErrorCode15 } from "@sip-protocol/types";
 
 // src/wallet/near/adapter.ts
-import { ed25519 as ed255193 } from "@noble/curves/ed25519";
-import { sha256 as sha25625 } from "@noble/hashes/sha2";
-import { bytesToHex as bytesToHex38, hexToBytes as hexToBytes26 } from "@noble/hashes/utils";
+import { ed25519 as ed255194 } from "@noble/curves/ed25519";
+import { sha256 as sha25626 } from "@noble/hashes/sha2";
+import { bytesToHex as bytesToHex40, hexToBytes as hexToBytes27 } from "@noble/hashes/utils";
 import { WalletErrorCode as WalletErrorCode16 } from "@sip-protocol/types";
 
 // src/chains/near/constants.ts
@@ -22017,11 +22032,11 @@ function deriveNEARStealthPrivateKey(stealthAddress, spendingPrivateKey, viewing
     viewingPrivateKey
   );
 }
-function checkNEARStealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+function checkNEARStealthAddress(stealthAddress, viewingPrivateKey, spendingPublicKey) {
   return checkEd25519StealthAddress(
     stealthAddress,
-    spendingPrivateKey,
-    viewingPrivateKey
+    viewingPrivateKey,
+    spendingPublicKey
   );
 }
 function ed25519PublicKeyToImplicitAccount(publicKey) {
@@ -22105,13 +22120,13 @@ function validateNEARStealthAddress(stealthAddress) {
 var ED25519_ORDER2 = 2n ** 252n + 27742317777372353535851937790883648493n;
 
 // src/wallet/near/wallet-selector.ts
-import { sha256 as sha25626 } from "@noble/hashes/sha2";
-import { bytesToHex as bytesToHex40, hexToBytes as hexToBytes28 } from "@noble/hashes/utils";
-import { ed25519 as ed255195 } from "@noble/curves/ed25519";
+import { sha256 as sha25627 } from "@noble/hashes/sha2";
+import { bytesToHex as bytesToHex42, hexToBytes as hexToBytes29 } from "@noble/hashes/utils";
+import { ed25519 as ed255196 } from "@noble/curves/ed25519";
 
 // src/chains/near/implicit-account.ts
-import { ed25519 as ed255194 } from "@noble/curves/ed25519";
-import { bytesToHex as bytesToHex39, hexToBytes as hexToBytes27 } from "@noble/hashes/utils";
+import { ed25519 as ed255195 } from "@noble/curves/ed25519";
+import { bytesToHex as bytesToHex41, hexToBytes as hexToBytes28 } from "@noble/hashes/utils";
 
 // src/chains/near/types.ts
 function parseAnnouncement(memo) {
@@ -22149,15 +22164,15 @@ function createAnnouncementMemo(ephemeralPublicKey, viewTag) {
 }
 
 // src/wallet/near/my-near-wallet.ts
-import { sha256 as sha25627 } from "@noble/hashes/sha2";
-import { bytesToHex as bytesToHex41 } from "@noble/hashes/utils";
-import { ed25519 as ed255196 } from "@noble/curves/ed25519";
-
-// src/wallet/near/meteor-wallet.ts
 import { sha256 as sha25628 } from "@noble/hashes/sha2";
-import { bytesToHex as bytesToHex42 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex43 } from "@noble/hashes/utils";
 import { ed25519 as ed255197 } from "@noble/curves/ed25519";
 
+// src/wallet/near/meteor-wallet.ts
+import { sha256 as sha25629 } from "@noble/hashes/sha2";
+import { bytesToHex as bytesToHex44 } from "@noble/hashes/utils";
+import { ed25519 as ed255198 } from "@noble/curves/ed25519";
+
 // src/wallet/hardware/types.ts
 var DerivationPath = {
   /** Ethereum: m/44'/60'/0'/0/index */
@@ -22437,7 +22452,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
    */
   async loadTransport() {
     try {
-      const module = await import("./TransportWebUSB-YQMAGJAJ.mjs");
+      const module = await import("./TransportWebUSB-2KITI5HD.mjs");
       return module.default;
     } catch {
       throw new HardwareWalletError(
@@ -22627,7 +22642,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
    * @see https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
    */
   buildRawEthereumTx(tx) {
-    const hexToBytes34 = (hex) => {
+    const hexToBytes35 = (hex) => {
       if (!hex || hex === "0x" || hex === "0x0" || hex === "0x00") {
         return new Uint8Array(0);
       }
@@ -22644,21 +22659,21 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
     const isEIP1559 = tx.maxFeePerGas !== void 0 && tx.maxPriorityFeePerGas !== void 0;
     if (isEIP1559) {
       const txData = [
-        hexToBytes34(`0x${tx.chainId.toString(16)}`),
+        hexToBytes35(`0x${tx.chainId.toString(16)}`),
         // chainId
-        hexToBytes34(tx.nonce),
+        hexToBytes35(tx.nonce),
         // nonce
-        hexToBytes34(tx.maxPriorityFeePerGas),
+        hexToBytes35(tx.maxPriorityFeePerGas),
         // maxPriorityFeePerGas
-        hexToBytes34(tx.maxFeePerGas),
+        hexToBytes35(tx.maxFeePerGas),
         // maxFeePerGas
-        hexToBytes34(tx.gasLimit),
+        hexToBytes35(tx.gasLimit),
         // gasLimit
-        hexToBytes34(tx.to),
+        hexToBytes35(tx.to),
         // to
-        hexToBytes34(tx.value),
+        hexToBytes35(tx.value),
         // value
-        hexToBytes34(tx.data),
+        hexToBytes35(tx.data),
         // data
         []
         // accessList (empty)
@@ -22677,19 +22692,19 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
         );
       }
       const txData = [
-        hexToBytes34(tx.nonce),
+        hexToBytes35(tx.nonce),
         // nonce
-        hexToBytes34(tx.gasPrice),
+        hexToBytes35(tx.gasPrice),
         // gasPrice
-        hexToBytes34(tx.gasLimit),
+        hexToBytes35(tx.gasLimit),
         // gasLimit
-        hexToBytes34(tx.to),
+        hexToBytes35(tx.to),
         // to
-        hexToBytes34(tx.value),
+        hexToBytes35(tx.value),
         // value
-        hexToBytes34(tx.data),
+        hexToBytes35(tx.data),
         // data
-        hexToBytes34(`0x${tx.chainId.toString(16)}`),
+        hexToBytes35(`0x${tx.chainId.toString(16)}`),
         // v (chainId for EIP-155)
         new Uint8Array(0),
         // r (empty for unsigned)
@@ -22766,9 +22781,9 @@ function createLedgerAdapter(config) {
 }
 
 // src/wallet/hardware/ledger-privacy.ts
-import { secp256k1 as secp256k18 } from "@noble/curves/secp256k1";
-import { sha256 as sha25629 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex43, hexToBytes as hexToBytes29 } from "@noble/hashes/utils";
+import { secp256k1 as secp256k19 } from "@noble/curves/secp256k1";
+import { sha256 as sha25630 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex45, hexToBytes as hexToBytes30 } from "@noble/hashes/utils";
 import { WalletErrorCode as WalletErrorCode18 } from "@sip-protocol/types";
 
 // src/wallet/hardware/trezor.ts
@@ -23211,7 +23226,7 @@ function createTrezorAdapter(config) {
 
 // src/wallet/hardware/mock.ts
 import { WalletErrorCode as WalletErrorCode20 } from "@sip-protocol/types";
-import { bytesToHex as bytesToHex44, randomBytes as randomBytes18 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex46, randomBytes as randomBytes18 } from "@noble/hashes/utils";
 var MockLedgerAdapter = class extends BaseWalletAdapter {
   chain;
   name = "mock-ledger";
@@ -23458,13 +23473,13 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
   generateMockAddress(index) {
     const bytes = randomBytes18(20);
     bytes[0] = index;
-    return `0x${bytesToHex44(bytes)}`;
+    return `0x${bytesToHex46(bytes)}`;
   }
   generateMockPublicKey(index) {
     const bytes = randomBytes18(33);
     bytes[0] = 2;
     bytes[1] = index;
-    return `0x${bytesToHex44(bytes)}`;
+    return `0x${bytesToHex46(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -23473,7 +23488,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 11;
     }
     sig[64] = 27;
-    return `0x${bytesToHex44(sig)}`;
+    return `0x${bytesToHex46(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -23664,13 +23679,13 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
   generateMockAddress(index) {
     const bytes = randomBytes18(20);
     bytes[0] = index + 100;
-    return `0x${bytesToHex44(bytes)}`;
+    return `0x${bytesToHex46(bytes)}`;
   }
   generateMockPublicKey(index) {
     const bytes = randomBytes18(33);
     bytes[0] = 3;
     bytes[1] = index + 100;
-    return `0x${bytesToHex44(bytes)}`;
+    return `0x${bytesToHex46(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -23679,7 +23694,7 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 17;
     }
     sig[64] = 28;
-    return `0x${bytesToHex44(sig)}`;
+    return `0x${bytesToHex46(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -24303,9 +24318,9 @@ var SolanaNoirVerifier = class {
     return vkeyBytes;
   }
   async hashBytes(bytes) {
-    const { sha256: sha25634 } = await import("@noble/hashes/sha256");
-    const { bytesToHex: bytesToHex55 } = await import("@noble/hashes/utils");
-    return bytesToHex55(sha25634(bytes));
+    const { sha256: sha25635 } = await import("@noble/hashes/sha256");
+    const { bytesToHex: bytesToHex57 } = await import("@noble/hashes/utils");
+    return bytesToHex57(sha25635(bytes));
   }
   hexToBytes(hex) {
     const h = hex.startsWith("0x") ? hex.slice(2) : hex;
@@ -24349,7 +24364,7 @@ import {
   Transaction as Transaction2,
   SystemProgram
 } from "@solana/web3.js";
-import { bytesToHex as bytesToHex45 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex47 } from "@noble/hashes/utils";
 var JITO_BLOCK_ENGINES = {
   mainnet: {
     amsterdam: "https://amsterdam.mainnet.block-engine.jito.wtf/api/v1",
@@ -24469,7 +24484,7 @@ var JitoRelayer = class {
     }
     const signatures = bundleTransactions.map((tx) => {
       if (tx instanceof VersionedTransaction2) {
-        return bytesToHex45(tx.signatures[0]);
+        return bytesToHex47(tx.signatures[0]);
       } else {
         return tx.signature?.toString() ?? "";
       }
@@ -24508,7 +24523,7 @@ var JitoRelayer = class {
       const bundleId = await this.sendBundle([serializedTx]);
       let signature;
       if (request.transaction instanceof VersionedTransaction2) {
-        signature = bytesToHex45(request.transaction.signatures[0]);
+        signature = bytesToHex47(request.transaction.signatures[0]);
       } else {
         signature = request.transaction.signature?.toString() ?? "";
       }
@@ -24731,11 +24746,11 @@ function createMainnetRelayer(rpcUrl) {
 }
 
 // src/chains/near/commitment.ts
-import { ed25519 as ed255198 } from "@noble/curves/ed25519";
-import { sha256 as sha25630 } from "@noble/hashes/sha2";
-import { bytesToHex as bytesToHex46, randomBytes as randomBytes19 } from "@noble/hashes/utils";
+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";
 var H_DOMAIN = "SIP-NEAR-PEDERSEN-GENERATOR-H-v1";
-var G = ed255198.ExtendedPoint.BASE;
+var G = ed255199.ExtendedPoint.BASE;
 var ED25519_ORDER3 = 2n ** 252n + 27742317777372353535851937790883648493n;
 var ED25519_COFACTOR = 8n;
 var MAX_NEAR_AMOUNT = 2n ** 128n - 1n;
@@ -24745,14 +24760,14 @@ function generateH() {
   let counter = 0;
   while (counter < 256) {
     const input = new TextEncoder().encode(`${H_DOMAIN}:${counter}`);
-    const hashBytes = sha25630(input);
+    const hashBytes = sha25631(input);
     try {
-      const rawPoint = ed255198.ExtendedPoint.fromHex(hashBytes);
+      const rawPoint = ed255199.ExtendedPoint.fromHex(hashBytes);
       const point = rawPoint.multiply(ED25519_COFACTOR);
-      if (!point.equals(ed255198.ExtendedPoint.ZERO)) {
+      if (!point.equals(ed255199.ExtendedPoint.ZERO)) {
         const gBytes = G.toRawBytes();
         const hBytes = point.toRawBytes();
-        if (bytesToHex46(gBytes) !== bytesToHex46(hBytes)) {
+        if (bytesToHex48(gBytes) !== bytesToHex48(hBytes)) {
           return point;
         }
       }
@@ -24782,7 +24797,7 @@ function bigIntToBytes(n, length) {
   }
   return result;
 }
-function hexToBytes30(hex) {
+function hexToBytes31(hex) {
   const result = new Uint8Array(hex.length / 2);
   for (let i = 0; i < hex.length; i += 2) {
     result[i / 2] = parseInt(hex.substring(i, i + 2), 16);
@@ -24821,15 +24836,15 @@ function commitNEAR(value, blinding) {
   }
   const rScalarBytes = bigIntToBytes(rScalar, 32);
   return {
-    commitment: `0x${bytesToHex46(C.toRawBytes())}`,
-    blinding: `0x${bytesToHex46(rScalarBytes)}`
+    commitment: `0x${bytesToHex48(C.toRawBytes())}`,
+    blinding: `0x${bytesToHex48(rScalarBytes)}`
   };
 }
 function verifyOpeningNEAR(commitment, value, blinding) {
   try {
-    const commitmentBytes = hexToBytes30(commitment.slice(2));
-    const C = ed255198.ExtendedPoint.fromHex(commitmentBytes);
-    const blindingBytes = hexToBytes30(blinding.slice(2));
+    const commitmentBytes = hexToBytes31(commitment.slice(2));
+    const C = ed255199.ExtendedPoint.fromHex(commitmentBytes);
+    const blindingBytes = hexToBytes31(blinding.slice(2));
     const rScalar = bytesToBigInt(blindingBytes) % ED25519_ORDER3;
     let expected;
     if (value === 0n) {
@@ -24904,18 +24919,18 @@ function addCommitmentsNEAR(c1, c2) {
   let point1;
   let point2;
   try {
-    point1 = ed255198.ExtendedPoint.fromHex(hexToBytes30(c1.slice(2)));
+    point1 = ed255199.ExtendedPoint.fromHex(hexToBytes31(c1.slice(2)));
   } catch {
     throw new ValidationError("must be a valid ed25519 point", "c1");
   }
   try {
-    point2 = ed255198.ExtendedPoint.fromHex(hexToBytes30(c2.slice(2)));
+    point2 = ed255199.ExtendedPoint.fromHex(hexToBytes31(c2.slice(2)));
   } catch {
     throw new ValidationError("must be a valid ed25519 point", "c2");
   }
   const sum = point1.add(point2);
   return {
-    commitment: `0x${bytesToHex46(sum.toRawBytes())}`
+    commitment: `0x${bytesToHex48(sum.toRawBytes())}`
   };
 }
 function subtractCommitmentsNEAR(c1, c2) {
@@ -24928,23 +24943,23 @@ function subtractCommitmentsNEAR(c1, c2) {
   let point1;
   let point2;
   try {
-    point1 = ed255198.ExtendedPoint.fromHex(hexToBytes30(c1.slice(2)));
+    point1 = ed255199.ExtendedPoint.fromHex(hexToBytes31(c1.slice(2)));
   } catch {
     throw new ValidationError("must be a valid ed25519 point", "c1");
   }
   try {
-    point2 = ed255198.ExtendedPoint.fromHex(hexToBytes30(c2.slice(2)));
+    point2 = ed255199.ExtendedPoint.fromHex(hexToBytes31(c2.slice(2)));
   } catch {
     throw new ValidationError("must be a valid ed25519 point", "c2");
   }
   const diff = point1.subtract(point2);
-  if (diff.equals(ed255198.ExtendedPoint.ZERO)) {
+  if (diff.equals(ed255199.ExtendedPoint.ZERO)) {
     return {
       commitment: "0x" + "00".repeat(32)
     };
   }
   return {
-    commitment: `0x${bytesToHex46(diff.toRawBytes())}`
+    commitment: `0x${bytesToHex48(diff.toRawBytes())}`
   };
 }
 function addBlindingsNEAR(b1, b2) {
@@ -24954,13 +24969,13 @@ function addBlindingsNEAR(b1, b2) {
   if (!isValidHex(b2)) {
     throw new ValidationError("must be a valid hex string", "b2");
   }
-  const b1Bytes = hexToBytes30(b1.slice(2));
-  const b2Bytes = hexToBytes30(b2.slice(2));
+  const b1Bytes = hexToBytes31(b1.slice(2));
+  const b2Bytes = hexToBytes31(b2.slice(2));
   const b1Scalar = bytesToBigInt(b1Bytes);
   const b2Scalar = bytesToBigInt(b2Bytes);
   const sum = (b1Scalar + b2Scalar) % ED25519_ORDER3;
   const sumBytes = bigIntToBytes(sum, 32);
-  return `0x${bytesToHex46(sumBytes)}`;
+  return `0x${bytesToHex48(sumBytes)}`;
 }
 function subtractBlindingsNEAR(b1, b2) {
   if (!isValidHex(b1)) {
@@ -24969,18 +24984,18 @@ function subtractBlindingsNEAR(b1, b2) {
   if (!isValidHex(b2)) {
     throw new ValidationError("must be a valid hex string", "b2");
   }
-  const b1Bytes = hexToBytes30(b1.slice(2));
-  const b2Bytes = hexToBytes30(b2.slice(2));
+  const b1Bytes = hexToBytes31(b1.slice(2));
+  const b2Bytes = hexToBytes31(b2.slice(2));
   const b1Scalar = bytesToBigInt(b1Bytes);
   const b2Scalar = bytesToBigInt(b2Bytes);
   const diff = (b1Scalar - b2Scalar + ED25519_ORDER3) % ED25519_ORDER3;
   const diffBytes = bigIntToBytes(diff, 32);
-  return `0x${bytesToHex46(diffBytes)}`;
+  return `0x${bytesToHex48(diffBytes)}`;
 }
 function getGeneratorsNEAR() {
   return {
-    G: `0x${bytesToHex46(G.toRawBytes())}`,
-    H: `0x${bytesToHex46(H.toRawBytes())}`
+    G: `0x${bytesToHex48(G.toRawBytes())}`,
+    H: `0x${bytesToHex48(H.toRawBytes())}`
   };
 }
 function generateBlindingNEAR() {
@@ -24990,15 +25005,15 @@ function generateBlindingNEAR() {
     return generateBlindingNEAR();
   }
   const scalarBytes = bigIntToBytes(scalar, 32);
-  return `0x${bytesToHex46(scalarBytes)}`;
+  return `0x${bytesToHex48(scalarBytes)}`;
 }
 
 // src/chains/near/viewing-key.ts
-import { ed25519 as ed255199 } from "@noble/curves/ed25519";
-import { sha256 as sha25631 } from "@noble/hashes/sha256";
+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 bytesToHex47, hexToBytes as hexToBytes31, randomBytes as randomBytes20, utf8ToBytes as utf8ToBytes7 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex49, 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";
@@ -25011,7 +25026,7 @@ function generateNEARViewingKeyFromSpending(spendingPrivateKey, label) {
       "spendingPrivateKey"
     );
   }
-  const spendingBytes = hexToBytes31(spendingPrivateKey.slice(2));
+  const spendingBytes = hexToBytes32(spendingPrivateKey.slice(2));
   if (spendingBytes.length !== 32) {
     throw new ValidationError(
       "spendingPrivateKey must be 32 bytes",
@@ -25021,16 +25036,16 @@ function generateNEARViewingKeyFromSpending(spendingPrivateKey, label) {
   let viewingPrivateBytes = null;
   try {
     viewingPrivateBytes = hmac4(
-      sha25631,
+      sha25632,
       utf8ToBytes7(VIEWING_KEY_CONTEXT),
       spendingBytes
     );
-    const viewingPublicBytes = ed255199.getPublicKey(viewingPrivateBytes);
-    const hashBytes = sha25631(viewingPublicBytes);
+    const viewingPublicBytes = ed2551910.getPublicKey(viewingPrivateBytes);
+    const hashBytes = sha25632(viewingPublicBytes);
     return {
-      privateKey: `0x${bytesToHex47(viewingPrivateBytes)}`,
-      publicKey: `0x${bytesToHex47(viewingPublicBytes)}`,
-      hash: `0x${bytesToHex47(hashBytes)}`,
+      privateKey: `0x${bytesToHex49(viewingPrivateBytes)}`,
+      publicKey: `0x${bytesToHex49(viewingPublicBytes)}`,
+      hash: `0x${bytesToHex49(hashBytes)}`,
       label,
       createdAt: Date.now()
     };
@@ -25042,12 +25057,12 @@ function generateNEARViewingKeyFromSpending(spendingPrivateKey, label) {
 function generateRandomNEARViewingKey(label) {
   const privateBytes = randomBytes20(32);
   try {
-    const publicBytes = ed255199.getPublicKey(privateBytes);
-    const hashBytes = sha25631(publicBytes);
+    const publicBytes = ed2551910.getPublicKey(privateBytes);
+    const hashBytes = sha25632(publicBytes);
     return {
-      privateKey: `0x${bytesToHex47(privateBytes)}`,
-      publicKey: `0x${bytesToHex47(publicBytes)}`,
-      hash: `0x${bytesToHex47(hashBytes)}`,
+      privateKey: `0x${bytesToHex49(privateBytes)}`,
+      publicKey: `0x${bytesToHex49(publicBytes)}`,
+      hash: `0x${bytesToHex49(hashBytes)}`,
       label,
       createdAt: Date.now()
     };
@@ -25062,15 +25077,15 @@ function computeNEARViewingKeyHash(viewingPublicKey) {
       "viewingPublicKey"
     );
   }
-  const publicBytes = hexToBytes31(viewingPublicKey.slice(2));
+  const publicBytes = hexToBytes32(viewingPublicKey.slice(2));
   if (publicBytes.length !== 32) {
     throw new ValidationError(
       "viewingPublicKey must be 32 bytes",
       "viewingPublicKey"
     );
   }
-  const hashBytes = sha25631(publicBytes);
-  return `0x${bytesToHex47(hashBytes)}`;
+  const hashBytes = sha25632(publicBytes);
+  return `0x${bytesToHex49(hashBytes)}`;
 }
 function computeNEARViewingKeyHashFromPrivate(viewingPrivateKey) {
   if (!viewingPrivateKey || !viewingPrivateKey.startsWith("0x")) {
@@ -25079,7 +25094,7 @@ function computeNEARViewingKeyHashFromPrivate(viewingPrivateKey) {
       "viewingPrivateKey"
     );
   }
-  const privateBytes = hexToBytes31(viewingPrivateKey.slice(2));
+  const privateBytes = hexToBytes32(viewingPrivateKey.slice(2));
   if (privateBytes.length !== 32) {
     throw new ValidationError(
       "viewingPrivateKey must be 32 bytes",
@@ -25087,9 +25102,9 @@ function computeNEARViewingKeyHashFromPrivate(viewingPrivateKey) {
     );
   }
   try {
-    const publicBytes = ed255199.getPublicKey(privateBytes);
-    const hashBytes = sha25631(publicBytes);
-    return `0x${bytesToHex47(hashBytes)}`;
+    const publicBytes = ed2551910.getPublicKey(privateBytes);
+    const hashBytes = sha25632(publicBytes);
+    return `0x${bytesToHex49(hashBytes)}`;
   } finally {
     secureWipe(privateBytes);
   }
@@ -25136,9 +25151,9 @@ function importNEARViewingKey(exported) {
       { expected: computedHash, received: exported.hash }
     );
   }
-  const privateBytes = hexToBytes31(exported.privateKey.slice(2));
+  const privateBytes = hexToBytes32(exported.privateKey.slice(2));
   try {
-    const derivedPublic = `0x${bytesToHex47(ed255199.getPublicKey(privateBytes))}`;
+    const derivedPublic = `0x${bytesToHex49(ed2551910.getPublicKey(privateBytes))}`;
     if (derivedPublic !== exported.publicKey) {
       throw new ValidationError(
         "Public key does not match private key",
@@ -25157,10 +25172,10 @@ function importNEARViewingKey(exported) {
   };
 }
 function deriveEncryptionKey2(key, salt) {
-  const keyBytes = hexToBytes31(key.slice(2));
+  const keyBytes = hexToBytes32(key.slice(2));
   try {
     const hkdfSalt = salt ?? utf8ToBytes7(ENCRYPTION_DOMAIN2);
-    return hkdf4(sha25631, keyBytes, hkdfSalt, utf8ToBytes7("encryption"), 32);
+    return hkdf4(sha25632, keyBytes, hkdfSalt, utf8ToBytes7("encryption"), 32);
   } finally {
     secureWipe(keyBytes);
   }
@@ -25173,8 +25188,8 @@ function encryptForNEARViewing(data, viewingKey) {
     const cipher = xchacha20poly13055(encKey, nonce);
     const ciphertext = cipher.encrypt(plaintext);
     return {
-      ciphertext: `0x${bytesToHex47(ciphertext)}`,
-      nonce: `0x${bytesToHex47(nonce)}`,
+      ciphertext: `0x${bytesToHex49(ciphertext)}`,
+      nonce: `0x${bytesToHex49(nonce)}`,
       viewingKeyHash: viewingKey.hash
     };
   } finally {
@@ -25191,8 +25206,8 @@ function decryptWithNEARViewing(encrypted, viewingKey) {
   }
   const encKey = deriveEncryptionKey2(viewingKey.privateKey);
   try {
-    const ciphertext = hexToBytes31(encrypted.ciphertext.slice(2));
-    const nonce = hexToBytes31(encrypted.nonce.slice(2));
+    const ciphertext = hexToBytes32(encrypted.ciphertext.slice(2));
+    const nonce = hexToBytes32(encrypted.nonce.slice(2));
     if (nonce.length !== NONCE_SIZE3) {
       throw new ValidationError(
         `Invalid nonce length: ${nonce.length}. Expected: ${NONCE_SIZE3}`,
@@ -25242,15 +25257,15 @@ function deriveNEARChildViewingKey(parentKey, childPath, label) {
   if (!childPath || typeof childPath !== "string") {
     throw new ValidationError("childPath must be a non-empty string", "childPath");
   }
-  const parentBytes = hexToBytes31(parentKey.privateKey.slice(2));
+  const parentBytes = hexToBytes32(parentKey.privateKey.slice(2));
   try {
-    const childBytes = hmac4(sha25631, utf8ToBytes7(childPath), parentBytes);
-    const publicBytes = ed255199.getPublicKey(childBytes);
-    const hashBytes = sha25631(publicBytes);
+    const childBytes = hmac4(sha25632, utf8ToBytes7(childPath), parentBytes);
+    const publicBytes = ed2551910.getPublicKey(childBytes);
+    const hashBytes = sha25632(publicBytes);
     const result = {
-      privateKey: `0x${bytesToHex47(childBytes)}`,
-      publicKey: `0x${bytesToHex47(publicBytes)}`,
-      hash: `0x${bytesToHex47(hashBytes)}`,
+      privateKey: `0x${bytesToHex49(childBytes)}`,
+      publicKey: `0x${bytesToHex49(publicBytes)}`,
+      hash: `0x${bytesToHex49(hashBytes)}`,
       label: label ?? `${parentKey.label ?? "Key"}/${childPath}`,
       createdAt: Date.now()
     };
@@ -25267,7 +25282,7 @@ function getNEARViewingPublicKey(viewingPrivateKey) {
       "viewingPrivateKey"
     );
   }
-  const privateBytes = hexToBytes31(viewingPrivateKey.slice(2));
+  const privateBytes = hexToBytes32(viewingPrivateKey.slice(2));
   if (privateBytes.length !== 32) {
     throw new ValidationError(
       "viewingPrivateKey must be 32 bytes",
@@ -25275,8 +25290,8 @@ function getNEARViewingPublicKey(viewingPrivateKey) {
     );
   }
   try {
-    const publicBytes = ed255199.getPublicKey(privateBytes);
-    return `0x${bytesToHex47(publicBytes)}`;
+    const publicBytes = ed2551910.getPublicKey(privateBytes);
+    return `0x${bytesToHex49(publicBytes)}`;
   } finally {
     secureWipe(privateBytes);
   }
@@ -25311,9 +25326,9 @@ function validateNEARViewingKey(viewingKey) {
       { expected: computedHash, received: viewingKey.hash }
     );
   }
-  const privateBytes = hexToBytes31(viewingKey.privateKey.slice(2));
+  const privateBytes = hexToBytes32(viewingKey.privateKey.slice(2));
   try {
-    const derivedPublic = `0x${bytesToHex47(ed255199.getPublicKey(privateBytes))}`;
+    const derivedPublic = `0x${bytesToHex49(ed2551910.getPublicKey(privateBytes))}`;
     if (derivedPublic !== viewingKey.publicKey) {
       throw new ValidationError(
         "publicKey does not match privateKey",
@@ -25327,7 +25342,11 @@ function validateNEARViewingKey(viewingKey) {
 }
 
 // src/chains/near/resolver.ts
-import { bytesToHex as bytesToHex48, hexToBytes as hexToBytes32 } from "@noble/hashes/utils";
+import { ed25519 as ed2551911 } from "@noble/curves/ed25519";
+import { bytesToHex as bytesToHex50, hexToBytes as hexToBytes33 } from "@noble/hashes/utils";
+function nearSpendingPublicFromPrivate(spendingPrivateKey) {
+  return `0x${bytesToHex50(ed2551911.getPublicKey(hexToBytes33(spendingPrivateKey.slice(2))))}`;
+}
 function createNEARAnnouncementCache() {
   const entries = [];
   return {
@@ -25573,11 +25592,11 @@ var NEARStealthScanner = class {
         try {
           const isMatch = checkNEARStealthAddress(
             stealthAddressToCheck,
-            recipient.spendingPrivateKey,
-            recipient.viewingPrivateKey
+            recipient.viewingPrivateKey,
+            nearSpendingPublicFromPrivate(recipient.spendingPrivateKey)
           );
           if (isMatch) {
-            const stealthAddress = isImplicitAccount(announcement.stealthAddress) ? announcement.stealthAddress : bytesToHex48(hexToBytes32(stealthPublicKey.slice(2)));
+            const stealthAddress = isImplicitAccount(announcement.stealthAddress) ? announcement.stealthAddress : bytesToHex50(hexToBytes33(stealthPublicKey.slice(2)));
             let amount = metadata?.amount ?? 0n;
             if (amount === 0n && isImplicitAccount(stealthAddress)) {
               try {
@@ -25659,8 +25678,8 @@ var NEARStealthScanner = class {
     try {
       return checkNEARStealthAddress(
         stealthAddressToCheck,
-        spendingPrivateKey,
-        viewingPrivateKey
+        viewingPrivateKey,
+        nearSpendingPublicFromPrivate(spendingPrivateKey)
       );
     } catch {
       return false;
@@ -25700,8 +25719,8 @@ var NEARStealthScanner = class {
         try {
           const isMatch = checkNEARStealthAddress(
             stealthAddressToCheck,
-            recipient.spendingPrivateKey,
-            recipient.viewingPrivateKey
+            recipient.viewingPrivateKey,
+            nearSpendingPublicFromPrivate(recipient.spendingPrivateKey)
           );
           if (isMatch) {
             matches.set(announcement.stealthAddress, recipient.label);
@@ -27937,7 +27956,7 @@ function createPrivacyLogger(moduleName, config = {}) {
 }
 
 // src/privacy-backends/privacycash.ts
-import { randomBytes as randomBytes21, bytesToHex as bytesToHex49 } from "@noble/hashes/utils";
+import { randomBytes as randomBytes21, bytesToHex as bytesToHex51 } from "@noble/hashes/utils";
 var privacyCashLogger = createPrivacyLogger("PrivacyCash");
 var DEFAULT_ANONYMITY_SET = 50;
 var BASE_COST_LAMPORTS = BigInt(1e7);
@@ -27973,7 +27992,7 @@ import {
   InvalidAmountError,
   InvalidAddressError
 } from "@radr/shadowwire";
-import { bytesToHex as bytesToHex50 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex52 } from "@noble/hashes/utils";
 var SHADOWWIRE_TOKEN_MINTS = {
   SOL: "So11111111111111111111111111111111111111112",
   USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
@@ -28003,8 +28022,14 @@ var SHADOWWIRE_TOKEN_MINTS = {
   // Placeholder - USD1 stablecoin
   AOL: "AOLexampleaddress11111111111111111111111111",
   // Placeholder
-  IQLABS: "IQLABSexampleaddress111111111111111111111"
+  IQLABS: "IQLABSexampleaddress111111111111111111111",
   // Placeholder - IQ Labs token
+  // Added in @radr/shadowwire@1.1.15 — real mints verified against the package's TOKEN_MINTS
+  SANA: "5dpN5wMH8j8au29Rp91qn4WfNq6t6xJfcjQNcFeDJ8Ct",
+  POKI: "6vK6cL9C66Bsqw7SC2hcCdkgm1UKBDUE6DCYJ4kubonk",
+  RAIN: "3iC63FgnB7EhcPaiSaC51UkVweeBDkqu17SaRyy2pump",
+  HOSICO: "Dx2bQe2UPv4k3BmcW8G2KhaL5oKsxduM5XxLSV3Sbonk",
+  SKR: "SKRbvo6Gf7GondiT3BbTfuRDPqLWei4j2Qy2NPGZhW3"
 };
 var MINT_TO_SYMBOL = Object.fromEntries(
   Object.entries(SHADOWWIRE_TOKEN_MINTS).map(([symbol, mint]) => [mint, symbol])
@@ -28037,7 +28062,7 @@ import {
   PublicKey as PublicKey4,
   Transaction as Transaction3
 } from "@solana/web3.js";
-import { bytesToHex as bytesToHex51 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex53 } from "@noble/hashes/utils";
 var magicBlockLogger = createPrivacyLogger("MagicBlock");
 
 // src/privacy-backends/cspl-types.ts
@@ -28725,8 +28750,8 @@ var CSPLClient = class {
 };
 
 // src/privacy-backends/private-swap.ts
-import { sha256 as sha25632 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex52 } from "@noble/hashes/utils";
+import { sha256 as sha25633 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex54 } from "@noble/hashes/utils";
 
 // src/privacy-backends/cspl-token.ts
 var CSPLTokenService = class {
@@ -31429,9 +31454,9 @@ function createProductionConfig(defaults) {
 }
 
 // src/sync/oblivious.ts
-import { sha256 as sha25633 } from "@noble/hashes/sha2";
+import { sha256 as sha25634 } from "@noble/hashes/sha2";
 import { hmac as hmac5 } from "@noble/hashes/hmac";
-import { bytesToHex as bytesToHex53, hexToBytes as hexToBytes33, randomBytes as randomBytes22, utf8ToBytes as utf8ToBytes8 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex55, hexToBytes as hexToBytes34, randomBytes as randomBytes22, utf8ToBytes as utf8ToBytes8 } from "@noble/hashes/utils";
 var DEFAULT_SYNC_CONFIG = {
   maxBatchSize: 1e3,
   timeoutMs: 3e4,
@@ -31457,10 +31482,10 @@ function getCurrentEpoch(epochDurationSeconds = DEFAULT_SYNC_CONFIG.epochDuratio
 }
 var OBLIVIOUS_NULLIFIER_DOMAIN = "SIP-OBLIVIOUS-NULLIFIER-V1";
 function deriveObliviousNullifier(noteCommitment, spendingKey, syncRandomness) {
-  const commitmentBytes = hexToBytes33(
+  const commitmentBytes = hexToBytes34(
     noteCommitment.startsWith("0x") ? noteCommitment.slice(2) : noteCommitment
   );
-  const keyBytes = hexToBytes33(
+  const keyBytes = hexToBytes34(
     spendingKey.startsWith("0x") ? spendingKey.slice(2) : spendingKey
   );
   try {
@@ -31469,9 +31494,9 @@ function deriveObliviousNullifier(noteCommitment, spendingKey, syncRandomness) {
     message.set(domain, 0);
     message.set(commitmentBytes, domain.length);
     message.set(syncRandomness.value, domain.length + commitmentBytes.length);
-    const nullifierBytes = hmac5(sha25633, keyBytes, message);
+    const nullifierBytes = hmac5(sha25634, keyBytes, message);
     return {
-      nullifier: `0x${bytesToHex53(nullifierBytes)}`,
+      nullifier: `0x${bytesToHex55(nullifierBytes)}`,
       epoch: syncRandomness.epoch,
       chainId: "default"
       // Will be set by caller
@@ -31481,15 +31506,15 @@ function deriveObliviousNullifier(noteCommitment, spendingKey, syncRandomness) {
   }
 }
 function deriveTraditionalNullifier(noteCommitment, spendingKey) {
-  const commitmentBytes = hexToBytes33(
+  const commitmentBytes = hexToBytes34(
     noteCommitment.startsWith("0x") ? noteCommitment.slice(2) : noteCommitment
   );
-  const keyBytes = hexToBytes33(
+  const keyBytes = hexToBytes34(
     spendingKey.startsWith("0x") ? spendingKey.slice(2) : spendingKey
   );
   try {
-    const nullifierBytes = hmac5(sha25633, keyBytes, commitmentBytes);
-    return `0x${bytesToHex53(nullifierBytes)}`;
+    const nullifierBytes = hmac5(sha25634, keyBytes, commitmentBytes);
+    return `0x${bytesToHex55(nullifierBytes)}`;
   } finally {
     secureWipe(keyBytes);
   }
@@ -31534,22 +31559,22 @@ function createTimeWindowedKey(masterViewingKey, startTime, endTime, epochDurati
   for (let e = startEpoch; e <= endEpoch; e++) {
     epochs.push(e);
   }
-  const keyBytes = hexToBytes33(
+  const keyBytes = hexToBytes34(
     masterViewingKey.startsWith("0x") ? masterViewingKey.slice(2) : masterViewingKey
   );
   const windowData = new Uint8Array(16);
   const view = new DataView(windowData.buffer);
   view.setBigUint64(0, BigInt(startTime), false);
   view.setBigUint64(8, BigInt(endTime), false);
-  const derivedKey = hmac5(sha25633, keyBytes, windowData);
-  const keyHash = sha25633(derivedKey);
+  const derivedKey = hmac5(sha25634, keyBytes, windowData);
+  const keyHash = sha25634(derivedKey);
   secureWipe(keyBytes);
   return {
-    viewingKey: `0x${bytesToHex53(derivedKey)}`,
+    viewingKey: `0x${bytesToHex55(derivedKey)}`,
     windowStart: startTime,
     windowEnd: endTime,
     epochs,
-    hash: `0x${bytesToHex53(keyHash)}`
+    hash: `0x${bytesToHex55(keyHash)}`
   };
 }
 function isNoteInWindow(_note, _windowedKey) {
@@ -31575,7 +31600,7 @@ var ObliviousSyncError = class extends Error {
 };
 
 // src/sync/mock-provider.ts
-import { bytesToHex as bytesToHex54, randomBytes as randomBytes23 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex56, randomBytes as randomBytes23 } from "@noble/hashes/utils";
 var DEFAULT_MOCK_CONFIG = {
   chains: ["ethereum", "solana", "near"],
   latencyMs: 100,
@@ -31672,7 +31697,7 @@ var MockObliviousSyncProvider = class {
       merkleProofs,
       syncHeight: this.config.blockHeight,
       timestamp: Date.now(),
-      queryHash: `0x${bytesToHex54(randomBytes23(32))}`
+      queryHash: `0x${bytesToHex56(randomBytes23(32))}`
     };
   }
   async getCurrentHeight(chainId) {
@@ -31753,23 +31778,23 @@ var MockObliviousSyncProvider = class {
   generateMockNote(blockRange) {
     const blockNumber = blockRange.startBlock + BigInt(Math.floor(Math.random() * Number(blockRange.endBlock - blockRange.startBlock)));
     return {
-      commitment: `0x${bytesToHex54(randomBytes23(32))}`,
-      encryptedData: `0x${bytesToHex54(randomBytes23(128))}`,
+      commitment: `0x${bytesToHex56(randomBytes23(32))}`,
+      encryptedData: `0x${bytesToHex56(randomBytes23(128))}`,
       blockNumber,
-      txHash: `0x${bytesToHex54(randomBytes23(32))}`,
+      txHash: `0x${bytesToHex56(randomBytes23(32))}`,
       chainId: blockRange.chainId
     };
   }
   generateMockMerkleProof(leaf) {
     const siblings = [];
     for (let i = 0; i < 20; i++) {
-      siblings.push(`0x${bytesToHex54(randomBytes23(32))}`);
+      siblings.push(`0x${bytesToHex56(randomBytes23(32))}`);
     }
     return {
       leaf,
       siblings,
       index: BigInt(Math.floor(Math.random() * 1e6)),
-      root: `0x${bytesToHex54(randomBytes23(32))}`
+      root: `0x${bytesToHex56(randomBytes23(32))}`
     };
   }
 };
@@ -33418,7 +33443,7 @@ export {
   supportsWASMBulkMemory,
   checkMobileWASMCompatibility,
   hexToBytes7 as hexToBytes,
-  bytesToHex10 as bytesToHex,
+  bytesToHex11 as bytesToHex,
   isBrowser,
   supportsWebWorkers,
   supportsSharedArrayBuffer,