@sip-protocol/sdk 0.8.0 → 0.9.0

package/dist/browser.js

@@ -18937,12 +18937,12 @@ async function createShieldedIntent(params, options) {
         "Using placeholder signatures for proof generation - NOT cryptographically valid"
       );
     } else {
-      const { secp256k1: secp256k112 } = await import("@noble/curves/secp256k1");
-      const publicKey = secp256k112.getPublicKey(effectiveSenderSecret, true);
+      const { secp256k1: secp256k113 } = await import("@noble/curves/secp256k1");
+      const publicKey = secp256k113.getPublicKey(effectiveSenderSecret, true);
       const senderAddressBytes = (0, import_sha2565.sha256)(publicKey);
-      const ownershipSig = secp256k112.sign(senderAddressBytes, effectiveSenderSecret);
+      const ownershipSig = secp256k113.sign(senderAddressBytes, effectiveSenderSecret);
       effectiveOwnershipSig = ownershipSig.toCompactRawBytes();
-      const authSig = secp256k112.sign(intentHashBytes, effectiveSenderSecret);
+      const authSig = secp256k113.sign(intentHashBytes, effectiveSenderSecret);
       effectiveAuthSig = authSig.toCompactRawBytes();
     }
     const fundingResult = await proofProvider.generateFundingProof({
@@ -40286,11 +40286,14 @@ function createEthereumAdapter(config) {
 
 // src/wallet/ethereum/privacy-adapter.ts
 var import_sha25 = require("@noble/hashes/sha2");
-var import_secp256k111 = require("@noble/curves/secp256k1");
+var import_secp256k112 = require("@noble/curves/secp256k1");
 var import_sha33 = require("@noble/hashes/sha3");
 
 // src/chains/ethereum/stealth.ts
+var import_secp256k110 = require("@noble/curves/secp256k1");
 init_secp256k1();
+init_utils();
+init_validation();
 init_errors();
 
 // src/chains/ethereum/constants.ts
@@ -40812,7 +40815,7 @@ var import_types64 = require("@sip-protocol/types");
 // src/wallet/near/adapter.ts
 var import_ed2551912 = require("@noble/curves/ed25519");
 var import_sha26 = require("@noble/hashes/sha2");
-var import_utils59 = require("@noble/hashes/utils");
+var import_utils60 = require("@noble/hashes/utils");
 var import_types66 = require("@sip-protocol/types");
 
 // src/chains/near/stealth.ts
@@ -41021,12 +41024,12 @@ var ED25519_ORDER5 = 2n ** 252n + 27742317777372353535851937790883648493n;
 
 // src/wallet/near/wallet-selector.ts
 var import_sha27 = require("@noble/hashes/sha2");
-var import_utils61 = require("@noble/hashes/utils");
+var import_utils62 = require("@noble/hashes/utils");
 var import_ed2551914 = require("@noble/curves/ed25519");
 
 // src/chains/near/implicit-account.ts
 var import_ed2551913 = require("@noble/curves/ed25519");
-var import_utils60 = require("@noble/hashes/utils");
+var import_utils61 = require("@noble/hashes/utils");
 init_errors();
 init_validation();
 
@@ -41067,12 +41070,12 @@ function createAnnouncementMemo2(ephemeralPublicKey, viewTag) {
 
 // src/wallet/near/my-near-wallet.ts
 var import_sha28 = require("@noble/hashes/sha2");
-var import_utils62 = require("@noble/hashes/utils");
+var import_utils63 = require("@noble/hashes/utils");
 var import_ed2551915 = require("@noble/curves/ed25519");
 
 // src/wallet/near/meteor-wallet.ts
 var import_sha29 = require("@noble/hashes/sha2");
-var import_utils63 = require("@noble/hashes/utils");
+var import_utils64 = require("@noble/hashes/utils");
 var import_ed2551916 = require("@noble/curves/ed25519");
 
 // src/wallet/hardware/types.ts
@@ -41683,9 +41686,9 @@ function createLedgerAdapter(config) {
 }
 
 // src/wallet/hardware/ledger-privacy.ts
-var import_secp256k112 = require("@noble/curves/secp256k1");
+var import_secp256k113 = require("@noble/curves/secp256k1");
 var import_sha25628 = require("@noble/hashes/sha256");
-var import_utils64 = require("@noble/hashes/utils");
+var import_utils65 = require("@noble/hashes/utils");
 var import_types70 = require("@sip-protocol/types");
 
 // src/wallet/hardware/trezor.ts
@@ -42128,7 +42131,7 @@ function createTrezorAdapter(config) {
 
 // src/wallet/hardware/mock.ts
 var import_types74 = require("@sip-protocol/types");
-var import_utils65 = require("@noble/hashes/utils");
+var import_utils66 = require("@noble/hashes/utils");
 var MockLedgerAdapter = class extends BaseWalletAdapter {
   chain;
   name = "mock-ledger";
@@ -42373,15 +42376,15 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = (0, import_utils65.randomBytes)(20);
+    const bytes = (0, import_utils66.randomBytes)(20);
     bytes[0] = index;
-    return `0x${(0, import_utils65.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils66.bytesToHex)(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = (0, import_utils65.randomBytes)(33);
+    const bytes = (0, import_utils66.randomBytes)(33);
     bytes[0] = 2;
     bytes[1] = index;
-    return `0x${(0, import_utils65.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils66.bytesToHex)(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -42390,7 +42393,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 11;
     }
     sig[64] = 27;
-    return `0x${(0, import_utils65.bytesToHex)(sig)}`;
+    return `0x${(0, import_utils66.bytesToHex)(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -42579,15 +42582,15 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = (0, import_utils65.randomBytes)(20);
+    const bytes = (0, import_utils66.randomBytes)(20);
     bytes[0] = index + 100;
-    return `0x${(0, import_utils65.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils66.bytesToHex)(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = (0, import_utils65.randomBytes)(33);
+    const bytes = (0, import_utils66.randomBytes)(33);
     bytes[0] = 3;
     bytes[1] = index + 100;
-    return `0x${(0, import_utils65.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils66.bytesToHex)(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -42596,7 +42599,7 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 17;
     }
     sig[64] = 28;
-    return `0x${(0, import_utils65.bytesToHex)(sig)}`;
+    return `0x${(0, import_utils66.bytesToHex)(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -43258,7 +43261,7 @@ function createMainnetVerifier(config = {}) {
 
 // src/solana/jito-relayer.ts
 var import_web317 = require("@solana/web3.js");
-var import_utils66 = require("@noble/hashes/utils");
+var import_utils67 = require("@noble/hashes/utils");
 var JITO_BLOCK_ENGINES = {
   mainnet: {
     amsterdam: "https://amsterdam.mainnet.block-engine.jito.wtf/api/v1",
@@ -43378,7 +43381,7 @@ var JitoRelayer = class {
     }
     const signatures = bundleTransactions.map((tx) => {
       if (tx instanceof import_web317.VersionedTransaction) {
-        return (0, import_utils66.bytesToHex)(tx.signatures[0]);
+        return (0, import_utils67.bytesToHex)(tx.signatures[0]);
       } else {
         return tx.signature?.toString() ?? "";
       }
@@ -43417,7 +43420,7 @@ var JitoRelayer = class {
       const bundleId = await this.sendBundle([serializedTx]);
       let signature;
       if (request.transaction instanceof import_web317.VersionedTransaction) {
-        signature = (0, import_utils66.bytesToHex)(request.transaction.signatures[0]);
+        signature = (0, import_utils67.bytesToHex)(request.transaction.signatures[0]);
       } else {
         signature = request.transaction.signature?.toString() ?? "";
       }
@@ -43642,7 +43645,7 @@ function createMainnetRelayer(rpcUrl) {
 // src/chains/near/commitment.ts
 var import_ed2551917 = require("@noble/curves/ed25519");
 var import_sha210 = require("@noble/hashes/sha2");
-var import_utils67 = require("@noble/hashes/utils");
+var import_utils68 = require("@noble/hashes/utils");
 init_errors();
 init_validation();
 var H_DOMAIN3 = "SIP-NEAR-PEDERSEN-GENERATOR-H-v1";
@@ -43663,7 +43666,7 @@ function generateH3() {
       if (!point.equals(import_ed2551917.ed25519.ExtendedPoint.ZERO)) {
         const gBytes = G3.toRawBytes();
         const hBytes = point.toRawBytes();
-        if ((0, import_utils67.bytesToHex)(gBytes) !== (0, import_utils67.bytesToHex)(hBytes)) {
+        if ((0, import_utils68.bytesToHex)(gBytes) !== (0, import_utils68.bytesToHex)(hBytes)) {
           return point;
         }
       }
@@ -43714,13 +43717,13 @@ function commitNEAR(value, blinding) {
       { curveOrder: ED25519_ORDER6.toString(16) }
     );
   }
-  const r = blinding ?? (0, import_utils67.randomBytes)(32);
+  const r = blinding ?? (0, import_utils68.randomBytes)(32);
   if (r.length !== 32) {
     throw new ValidationError("must be 32 bytes", "blinding", { received: r.length });
   }
   const rScalar = bytesToBigInt4(r) % ED25519_ORDER6;
   if (rScalar === 0n) {
-    return commitNEAR(value, (0, import_utils67.randomBytes)(32));
+    return commitNEAR(value, (0, import_utils68.randomBytes)(32));
   }
   let C;
   if (value === 0n) {
@@ -43732,8 +43735,8 @@ function commitNEAR(value, blinding) {
   }
   const rScalarBytes = bigIntToBytes4(rScalar, 32);
   return {
-    commitment: `0x${(0, import_utils67.bytesToHex)(C.toRawBytes())}`,
-    blinding: `0x${(0, import_utils67.bytesToHex)(rScalarBytes)}`
+    commitment: `0x${(0, import_utils68.bytesToHex)(C.toRawBytes())}`,
+    blinding: `0x${(0, import_utils68.bytesToHex)(rScalarBytes)}`
   };
 }
 function verifyOpeningNEAR(commitment, value, blinding) {
@@ -43826,7 +43829,7 @@ function addCommitmentsNEAR(c1, c2) {
   }
   const sum = point1.add(point2);
   return {
-    commitment: `0x${(0, import_utils67.bytesToHex)(sum.toRawBytes())}`
+    commitment: `0x${(0, import_utils68.bytesToHex)(sum.toRawBytes())}`
   };
 }
 function subtractCommitmentsNEAR(c1, c2) {
@@ -43855,7 +43858,7 @@ function subtractCommitmentsNEAR(c1, c2) {
     };
   }
   return {
-    commitment: `0x${(0, import_utils67.bytesToHex)(diff.toRawBytes())}`
+    commitment: `0x${(0, import_utils68.bytesToHex)(diff.toRawBytes())}`
   };
 }
 function addBlindingsNEAR(b1, b2) {
@@ -43871,7 +43874,7 @@ function addBlindingsNEAR(b1, b2) {
   const b2Scalar = bytesToBigInt4(b2Bytes);
   const sum = (b1Scalar + b2Scalar) % ED25519_ORDER6;
   const sumBytes = bigIntToBytes4(sum, 32);
-  return `0x${(0, import_utils67.bytesToHex)(sumBytes)}`;
+  return `0x${(0, import_utils68.bytesToHex)(sumBytes)}`;
 }
 function subtractBlindingsNEAR(b1, b2) {
   if (!isValidHex(b1)) {
@@ -43886,22 +43889,22 @@ function subtractBlindingsNEAR(b1, b2) {
   const b2Scalar = bytesToBigInt4(b2Bytes);
   const diff = (b1Scalar - b2Scalar + ED25519_ORDER6) % ED25519_ORDER6;
   const diffBytes = bigIntToBytes4(diff, 32);
-  return `0x${(0, import_utils67.bytesToHex)(diffBytes)}`;
+  return `0x${(0, import_utils68.bytesToHex)(diffBytes)}`;
 }
 function getGeneratorsNEAR() {
   return {
-    G: `0x${(0, import_utils67.bytesToHex)(G3.toRawBytes())}`,
-    H: `0x${(0, import_utils67.bytesToHex)(H3.toRawBytes())}`
+    G: `0x${(0, import_utils68.bytesToHex)(G3.toRawBytes())}`,
+    H: `0x${(0, import_utils68.bytesToHex)(H3.toRawBytes())}`
   };
 }
 function generateBlindingNEAR() {
-  const bytes = (0, import_utils67.randomBytes)(32);
+  const bytes = (0, import_utils68.randomBytes)(32);
   const scalar = bytesToBigInt4(bytes) % ED25519_ORDER6;
   if (scalar === 0n) {
     return generateBlindingNEAR();
   }
   const scalarBytes = bigIntToBytes4(scalar, 32);
-  return `0x${(0, import_utils67.bytesToHex)(scalarBytes)}`;
+  return `0x${(0, import_utils68.bytesToHex)(scalarBytes)}`;
 }
 
 // src/chains/near/viewing-key.ts
@@ -43909,7 +43912,7 @@ var import_ed2551918 = require("@noble/curves/ed25519");
 var import_sha25629 = require("@noble/hashes/sha256");
 var import_hmac7 = require("@noble/hashes/hmac");
 var import_hkdf5 = require("@noble/hashes/hkdf");
-var import_utils68 = require("@noble/hashes/utils");
+var import_utils69 = require("@noble/hashes/utils");
 var import_chacha6 = require("@noble/ciphers/chacha.js");
 init_errors();
 init_validation();
@@ -43925,7 +43928,7 @@ function generateNEARViewingKeyFromSpending(spendingPrivateKey, label) {
       "spendingPrivateKey"
     );
   }
-  const spendingBytes = (0, import_utils68.hexToBytes)(spendingPrivateKey.slice(2));
+  const spendingBytes = (0, import_utils69.hexToBytes)(spendingPrivateKey.slice(2));
   if (spendingBytes.length !== 32) {
     throw new ValidationError(
       "spendingPrivateKey must be 32 bytes",
@@ -43936,15 +43939,15 @@ function generateNEARViewingKeyFromSpending(spendingPrivateKey, label) {
   try {
     viewingPrivateBytes = (0, import_hmac7.hmac)(
       import_sha25629.sha256,
-      (0, import_utils68.utf8ToBytes)(VIEWING_KEY_CONTEXT3),
+      (0, import_utils69.utf8ToBytes)(VIEWING_KEY_CONTEXT3),
       spendingBytes
     );
     const viewingPublicBytes = import_ed2551918.ed25519.getPublicKey(viewingPrivateBytes);
     const hashBytes = (0, import_sha25629.sha256)(viewingPublicBytes);
     return {
-      privateKey: `0x${(0, import_utils68.bytesToHex)(viewingPrivateBytes)}`,
-      publicKey: `0x${(0, import_utils68.bytesToHex)(viewingPublicBytes)}`,
-      hash: `0x${(0, import_utils68.bytesToHex)(hashBytes)}`,
+      privateKey: `0x${(0, import_utils69.bytesToHex)(viewingPrivateBytes)}`,
+      publicKey: `0x${(0, import_utils69.bytesToHex)(viewingPublicBytes)}`,
+      hash: `0x${(0, import_utils69.bytesToHex)(hashBytes)}`,
       label,
       createdAt: Date.now()
     };
@@ -43954,14 +43957,14 @@ function generateNEARViewingKeyFromSpending(spendingPrivateKey, label) {
   }
 }
 function generateRandomNEARViewingKey(label) {
-  const privateBytes = (0, import_utils68.randomBytes)(32);
+  const privateBytes = (0, import_utils69.randomBytes)(32);
   try {
     const publicBytes = import_ed2551918.ed25519.getPublicKey(privateBytes);
     const hashBytes = (0, import_sha25629.sha256)(publicBytes);
     return {
-      privateKey: `0x${(0, import_utils68.bytesToHex)(privateBytes)}`,
-      publicKey: `0x${(0, import_utils68.bytesToHex)(publicBytes)}`,
-      hash: `0x${(0, import_utils68.bytesToHex)(hashBytes)}`,
+      privateKey: `0x${(0, import_utils69.bytesToHex)(privateBytes)}`,
+      publicKey: `0x${(0, import_utils69.bytesToHex)(publicBytes)}`,
+      hash: `0x${(0, import_utils69.bytesToHex)(hashBytes)}`,
       label,
       createdAt: Date.now()
     };
@@ -43976,7 +43979,7 @@ function computeNEARViewingKeyHash(viewingPublicKey) {
       "viewingPublicKey"
     );
   }
-  const publicBytes = (0, import_utils68.hexToBytes)(viewingPublicKey.slice(2));
+  const publicBytes = (0, import_utils69.hexToBytes)(viewingPublicKey.slice(2));
   if (publicBytes.length !== 32) {
     throw new ValidationError(
       "viewingPublicKey must be 32 bytes",
@@ -43984,7 +43987,7 @@ function computeNEARViewingKeyHash(viewingPublicKey) {
     );
   }
   const hashBytes = (0, import_sha25629.sha256)(publicBytes);
-  return `0x${(0, import_utils68.bytesToHex)(hashBytes)}`;
+  return `0x${(0, import_utils69.bytesToHex)(hashBytes)}`;
 }
 function computeNEARViewingKeyHashFromPrivate(viewingPrivateKey) {
   if (!viewingPrivateKey || !viewingPrivateKey.startsWith("0x")) {
@@ -43993,7 +43996,7 @@ function computeNEARViewingKeyHashFromPrivate(viewingPrivateKey) {
       "viewingPrivateKey"
     );
   }
-  const privateBytes = (0, import_utils68.hexToBytes)(viewingPrivateKey.slice(2));
+  const privateBytes = (0, import_utils69.hexToBytes)(viewingPrivateKey.slice(2));
   if (privateBytes.length !== 32) {
     throw new ValidationError(
       "viewingPrivateKey must be 32 bytes",
@@ -44003,7 +44006,7 @@ function computeNEARViewingKeyHashFromPrivate(viewingPrivateKey) {
   try {
     const publicBytes = import_ed2551918.ed25519.getPublicKey(privateBytes);
     const hashBytes = (0, import_sha25629.sha256)(publicBytes);
-    return `0x${(0, import_utils68.bytesToHex)(hashBytes)}`;
+    return `0x${(0, import_utils69.bytesToHex)(hashBytes)}`;
   } finally {
     secureWipe(privateBytes);
   }
@@ -44050,9 +44053,9 @@ function importNEARViewingKey(exported) {
       { expected: computedHash, received: exported.hash }
     );
   }
-  const privateBytes = (0, import_utils68.hexToBytes)(exported.privateKey.slice(2));
+  const privateBytes = (0, import_utils69.hexToBytes)(exported.privateKey.slice(2));
   try {
-    const derivedPublic = `0x${(0, import_utils68.bytesToHex)(import_ed2551918.ed25519.getPublicKey(privateBytes))}`;
+    const derivedPublic = `0x${(0, import_utils69.bytesToHex)(import_ed2551918.ed25519.getPublicKey(privateBytes))}`;
     if (derivedPublic !== exported.publicKey) {
       throw new ValidationError(
         "Public key does not match private key",
@@ -44071,10 +44074,10 @@ function importNEARViewingKey(exported) {
   };
 }
 function deriveEncryptionKey3(key, salt) {
-  const keyBytes = (0, import_utils68.hexToBytes)(key.slice(2));
+  const keyBytes = (0, import_utils69.hexToBytes)(key.slice(2));
   try {
-    const hkdfSalt = salt ?? (0, import_utils68.utf8ToBytes)(ENCRYPTION_DOMAIN3);
-    return (0, import_hkdf5.hkdf)(import_sha25629.sha256, keyBytes, hkdfSalt, (0, import_utils68.utf8ToBytes)("encryption"), 32);
+    const hkdfSalt = salt ?? (0, import_utils69.utf8ToBytes)(ENCRYPTION_DOMAIN3);
+    return (0, import_hkdf5.hkdf)(import_sha25629.sha256, keyBytes, hkdfSalt, (0, import_utils69.utf8ToBytes)("encryption"), 32);
   } finally {
     secureWipe(keyBytes);
   }
@@ -44082,13 +44085,13 @@ function deriveEncryptionKey3(key, salt) {
 function encryptForNEARViewing(data, viewingKey) {
   const encKey = deriveEncryptionKey3(viewingKey.privateKey);
   try {
-    const nonce = (0, import_utils68.randomBytes)(NONCE_SIZE4);
-    const plaintext = (0, import_utils68.utf8ToBytes)(JSON.stringify(data));
+    const nonce = (0, import_utils69.randomBytes)(NONCE_SIZE4);
+    const plaintext = (0, import_utils69.utf8ToBytes)(JSON.stringify(data));
     const cipher = (0, import_chacha6.xchacha20poly1305)(encKey, nonce);
     const ciphertext = cipher.encrypt(plaintext);
     return {
-      ciphertext: `0x${(0, import_utils68.bytesToHex)(ciphertext)}`,
-      nonce: `0x${(0, import_utils68.bytesToHex)(nonce)}`,
+      ciphertext: `0x${(0, import_utils69.bytesToHex)(ciphertext)}`,
+      nonce: `0x${(0, import_utils69.bytesToHex)(nonce)}`,
       viewingKeyHash: viewingKey.hash
     };
   } finally {
@@ -44105,8 +44108,8 @@ function decryptWithNEARViewing(encrypted, viewingKey) {
   }
   const encKey = deriveEncryptionKey3(viewingKey.privateKey);
   try {
-    const ciphertext = (0, import_utils68.hexToBytes)(encrypted.ciphertext.slice(2));
-    const nonce = (0, import_utils68.hexToBytes)(encrypted.nonce.slice(2));
+    const ciphertext = (0, import_utils69.hexToBytes)(encrypted.ciphertext.slice(2));
+    const nonce = (0, import_utils69.hexToBytes)(encrypted.nonce.slice(2));
     if (nonce.length !== NONCE_SIZE4) {
       throw new ValidationError(
         `Invalid nonce length: ${nonce.length}. Expected: ${NONCE_SIZE4}`,
@@ -44156,15 +44159,15 @@ function deriveNEARChildViewingKey(parentKey, childPath, label) {
   if (!childPath || typeof childPath !== "string") {
     throw new ValidationError("childPath must be a non-empty string", "childPath");
   }
-  const parentBytes = (0, import_utils68.hexToBytes)(parentKey.privateKey.slice(2));
+  const parentBytes = (0, import_utils69.hexToBytes)(parentKey.privateKey.slice(2));
   try {
-    const childBytes = (0, import_hmac7.hmac)(import_sha25629.sha256, (0, import_utils68.utf8ToBytes)(childPath), parentBytes);
+    const childBytes = (0, import_hmac7.hmac)(import_sha25629.sha256, (0, import_utils69.utf8ToBytes)(childPath), parentBytes);
     const publicBytes = import_ed2551918.ed25519.getPublicKey(childBytes);
     const hashBytes = (0, import_sha25629.sha256)(publicBytes);
     const result = {
-      privateKey: `0x${(0, import_utils68.bytesToHex)(childBytes)}`,
-      publicKey: `0x${(0, import_utils68.bytesToHex)(publicBytes)}`,
-      hash: `0x${(0, import_utils68.bytesToHex)(hashBytes)}`,
+      privateKey: `0x${(0, import_utils69.bytesToHex)(childBytes)}`,
+      publicKey: `0x${(0, import_utils69.bytesToHex)(publicBytes)}`,
+      hash: `0x${(0, import_utils69.bytesToHex)(hashBytes)}`,
       label: label ?? `${parentKey.label ?? "Key"}/${childPath}`,
       createdAt: Date.now()
     };
@@ -44181,7 +44184,7 @@ function getNEARViewingPublicKey(viewingPrivateKey) {
       "viewingPrivateKey"
     );
   }
-  const privateBytes = (0, import_utils68.hexToBytes)(viewingPrivateKey.slice(2));
+  const privateBytes = (0, import_utils69.hexToBytes)(viewingPrivateKey.slice(2));
   if (privateBytes.length !== 32) {
     throw new ValidationError(
       "viewingPrivateKey must be 32 bytes",
@@ -44190,7 +44193,7 @@ function getNEARViewingPublicKey(viewingPrivateKey) {
   }
   try {
     const publicBytes = import_ed2551918.ed25519.getPublicKey(privateBytes);
-    return `0x${(0, import_utils68.bytesToHex)(publicBytes)}`;
+    return `0x${(0, import_utils69.bytesToHex)(publicBytes)}`;
   } finally {
     secureWipe(privateBytes);
   }
@@ -44225,9 +44228,9 @@ function validateNEARViewingKey(viewingKey) {
       { expected: computedHash, received: viewingKey.hash }
     );
   }
-  const privateBytes = (0, import_utils68.hexToBytes)(viewingKey.privateKey.slice(2));
+  const privateBytes = (0, import_utils69.hexToBytes)(viewingKey.privateKey.slice(2));
   try {
-    const derivedPublic = `0x${(0, import_utils68.bytesToHex)(import_ed2551918.ed25519.getPublicKey(privateBytes))}`;
+    const derivedPublic = `0x${(0, import_utils69.bytesToHex)(import_ed2551918.ed25519.getPublicKey(privateBytes))}`;
     if (derivedPublic !== viewingKey.publicKey) {
       throw new ValidationError(
         "publicKey does not match privateKey",
@@ -44241,7 +44244,7 @@ function validateNEARViewingKey(viewingKey) {
 }
 
 // src/chains/near/resolver.ts
-var import_utils69 = require("@noble/hashes/utils");
+var import_utils70 = require("@noble/hashes/utils");
 init_errors();
 init_validation();
 function createNEARAnnouncementCache() {
@@ -44493,7 +44496,7 @@ var NEARStealthScanner = class {
             recipient.viewingPrivateKey
           );
           if (isMatch) {
-            const stealthAddress = isImplicitAccount(announcement.stealthAddress) ? announcement.stealthAddress : (0, import_utils69.bytesToHex)((0, import_utils69.hexToBytes)(stealthPublicKey.slice(2)));
+            const stealthAddress = isImplicitAccount(announcement.stealthAddress) ? announcement.stealthAddress : (0, import_utils70.bytesToHex)((0, import_utils70.hexToBytes)(stealthPublicKey.slice(2)));
             let amount = metadata?.amount ?? 0n;
             if (amount === 0n && isImplicitAccount(stealthAddress)) {
               try {
@@ -46868,7 +46871,7 @@ function createPrivacyLogger(moduleName, config = {}) {
 }
 
 // src/privacy-backends/privacycash.ts
-var import_utils70 = require("@noble/hashes/utils");
+var import_utils71 = require("@noble/hashes/utils");
 var privacyCashLogger = createPrivacyLogger("PrivacyCash");
 var DEFAULT_ANONYMITY_SET = 50;
 var BASE_COST_LAMPORTS = BigInt(1e7);
@@ -46898,7 +46901,7 @@ var PRIVACYCASH_CAPABILITIES = {
 
 // src/privacy-backends/shadowwire.ts
 var import_shadowwire = require("@radr/shadowwire");
-var import_utils71 = require("@noble/hashes/utils");
+var import_utils72 = require("@noble/hashes/utils");
 var SHADOWWIRE_TOKEN_MINTS = {
   SOL: "So11111111111111111111111111111111111111112",
   USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
@@ -46952,7 +46955,7 @@ var COST_PER_ENCRYPTED_INPUT_WEI = BigInt("1000000000000000");
 // src/privacy-backends/magicblock.ts
 var import_ephemeral_rollups_sdk = require("@magicblock-labs/ephemeral-rollups-sdk");
 var import_web318 = require("@solana/web3.js");
-var import_utils72 = require("@noble/hashes/utils");
+var import_utils73 = require("@noble/hashes/utils");
 var magicBlockLogger = createPrivacyLogger("MagicBlock");
 
 // src/privacy-backends/cspl-types.ts
@@ -47642,7 +47645,7 @@ var CSPLClient = class {
 
 // src/privacy-backends/private-swap.ts
 var import_sha25630 = require("@noble/hashes/sha256");
-var import_utils73 = require("@noble/hashes/utils");
+var import_utils74 = require("@noble/hashes/utils");
 
 // src/privacy-backends/cspl-token.ts
 var CSPLTokenService = class {
@@ -50353,7 +50356,7 @@ init_proxy();
 // src/sync/oblivious.ts
 var import_sha211 = require("@noble/hashes/sha2");
 var import_hmac8 = require("@noble/hashes/hmac");
-var import_utils74 = require("@noble/hashes/utils");
+var import_utils75 = require("@noble/hashes/utils");
 init_secure_memory();
 var DEFAULT_SYNC_CONFIG = {
   maxBatchSize: 1e3,
@@ -50364,7 +50367,7 @@ var DEFAULT_SYNC_CONFIG = {
   parallelSync: true
 };
 function generateSyncRandomness(epoch, durationSeconds = DEFAULT_SYNC_CONFIG.epochDurationSeconds) {
-  const value = (0, import_utils74.randomBytes)(32);
+  const value = (0, import_utils75.randomBytes)(32);
   const expiresAt = Date.now() + durationSeconds * 1e3;
   return {
     value,
@@ -50380,21 +50383,21 @@ function getCurrentEpoch(epochDurationSeconds = DEFAULT_SYNC_CONFIG.epochDuratio
 }
 var OBLIVIOUS_NULLIFIER_DOMAIN = "SIP-OBLIVIOUS-NULLIFIER-V1";
 function deriveObliviousNullifier(noteCommitment, spendingKey, syncRandomness) {
-  const commitmentBytes = (0, import_utils74.hexToBytes)(
+  const commitmentBytes = (0, import_utils75.hexToBytes)(
     noteCommitment.startsWith("0x") ? noteCommitment.slice(2) : noteCommitment
   );
-  const keyBytes = (0, import_utils74.hexToBytes)(
+  const keyBytes = (0, import_utils75.hexToBytes)(
     spendingKey.startsWith("0x") ? spendingKey.slice(2) : spendingKey
   );
   try {
-    const domain = (0, import_utils74.utf8ToBytes)(OBLIVIOUS_NULLIFIER_DOMAIN);
+    const domain = (0, import_utils75.utf8ToBytes)(OBLIVIOUS_NULLIFIER_DOMAIN);
     const message = new Uint8Array(domain.length + commitmentBytes.length + syncRandomness.value.length);
     message.set(domain, 0);
     message.set(commitmentBytes, domain.length);
     message.set(syncRandomness.value, domain.length + commitmentBytes.length);
     const nullifierBytes = (0, import_hmac8.hmac)(import_sha211.sha256, keyBytes, message);
     return {
-      nullifier: `0x${(0, import_utils74.bytesToHex)(nullifierBytes)}`,
+      nullifier: `0x${(0, import_utils75.bytesToHex)(nullifierBytes)}`,
       epoch: syncRandomness.epoch,
       chainId: "default"
       // Will be set by caller
@@ -50404,15 +50407,15 @@ function deriveObliviousNullifier(noteCommitment, spendingKey, syncRandomness) {
   }
 }
 function deriveTraditionalNullifier(noteCommitment, spendingKey) {
-  const commitmentBytes = (0, import_utils74.hexToBytes)(
+  const commitmentBytes = (0, import_utils75.hexToBytes)(
     noteCommitment.startsWith("0x") ? noteCommitment.slice(2) : noteCommitment
   );
-  const keyBytes = (0, import_utils74.hexToBytes)(
+  const keyBytes = (0, import_utils75.hexToBytes)(
     spendingKey.startsWith("0x") ? spendingKey.slice(2) : spendingKey
   );
   try {
     const nullifierBytes = (0, import_hmac8.hmac)(import_sha211.sha256, keyBytes, commitmentBytes);
-    return `0x${(0, import_utils74.bytesToHex)(nullifierBytes)}`;
+    return `0x${(0, import_utils75.bytesToHex)(nullifierBytes)}`;
   } finally {
     secureWipe(keyBytes);
   }
@@ -50457,7 +50460,7 @@ function createTimeWindowedKey(masterViewingKey, startTime, endTime, epochDurati
   for (let e = startEpoch; e <= endEpoch; e++) {
     epochs.push(e);
   }
-  const keyBytes = (0, import_utils74.hexToBytes)(
+  const keyBytes = (0, import_utils75.hexToBytes)(
     masterViewingKey.startsWith("0x") ? masterViewingKey.slice(2) : masterViewingKey
   );
   const windowData = new Uint8Array(16);
@@ -50468,11 +50471,11 @@ function createTimeWindowedKey(masterViewingKey, startTime, endTime, epochDurati
   const keyHash = (0, import_sha211.sha256)(derivedKey);
   secureWipe(keyBytes);
   return {
-    viewingKey: `0x${(0, import_utils74.bytesToHex)(derivedKey)}`,
+    viewingKey: `0x${(0, import_utils75.bytesToHex)(derivedKey)}`,
     windowStart: startTime,
     windowEnd: endTime,
     epochs,
-    hash: `0x${(0, import_utils74.bytesToHex)(keyHash)}`
+    hash: `0x${(0, import_utils75.bytesToHex)(keyHash)}`
   };
 }
 function isNoteInWindow(_note, _windowedKey) {
@@ -50498,7 +50501,7 @@ var ObliviousSyncError = class extends Error {
 };
 
 // src/sync/mock-provider.ts
-var import_utils75 = require("@noble/hashes/utils");
+var import_utils76 = require("@noble/hashes/utils");
 var DEFAULT_MOCK_CONFIG = {
   chains: ["ethereum", "solana", "near"],
   latencyMs: 100,
@@ -50595,7 +50598,7 @@ var MockObliviousSyncProvider = class {
       merkleProofs,
       syncHeight: this.config.blockHeight,
       timestamp: Date.now(),
-      queryHash: `0x${(0, import_utils75.bytesToHex)((0, import_utils75.randomBytes)(32))}`
+      queryHash: `0x${(0, import_utils76.bytesToHex)((0, import_utils76.randomBytes)(32))}`
     };
   }
   async getCurrentHeight(chainId) {
@@ -50676,23 +50679,23 @@ var MockObliviousSyncProvider = class {
   generateMockNote(blockRange) {
     const blockNumber = blockRange.startBlock + BigInt(Math.floor(Math.random() * Number(blockRange.endBlock - blockRange.startBlock)));
     return {
-      commitment: `0x${(0, import_utils75.bytesToHex)((0, import_utils75.randomBytes)(32))}`,
-      encryptedData: `0x${(0, import_utils75.bytesToHex)((0, import_utils75.randomBytes)(128))}`,
+      commitment: `0x${(0, import_utils76.bytesToHex)((0, import_utils76.randomBytes)(32))}`,
+      encryptedData: `0x${(0, import_utils76.bytesToHex)((0, import_utils76.randomBytes)(128))}`,
       blockNumber,
-      txHash: `0x${(0, import_utils75.bytesToHex)((0, import_utils75.randomBytes)(32))}`,
+      txHash: `0x${(0, import_utils76.bytesToHex)((0, import_utils76.randomBytes)(32))}`,
       chainId: blockRange.chainId
     };
   }
   generateMockMerkleProof(leaf) {
     const siblings = [];
     for (let i = 0; i < 20; i++) {
-      siblings.push(`0x${(0, import_utils75.bytesToHex)((0, import_utils75.randomBytes)(32))}`);
+      siblings.push(`0x${(0, import_utils76.bytesToHex)((0, import_utils76.randomBytes)(32))}`);
     }
     return {
       leaf,
       siblings,
       index: BigInt(Math.floor(Math.random() * 1e6)),
-      root: `0x${(0, import_utils75.bytesToHex)((0, import_utils75.randomBytes)(32))}`
+      root: `0x${(0, import_utils76.bytesToHex)((0, import_utils76.randomBytes)(32))}`
     };
   }
 };
@@ -52270,7 +52273,7 @@ async function calculateFeeForSwap(contract, swapAmount, swapAmountUsd, sourceCh
 init_errors();
 var import_noir_js = require("@noir-lang/noir_js");
 var import_bb = require("@aztec/bb.js");
-var import_secp256k113 = require("@noble/curves/secp256k1");
+var import_secp256k114 = require("@noble/curves/secp256k1");
 var import_funding_proof = __toESM(require_funding_proof());
 var import_validity_proof = __toESM(require_validity_proof());
 var import_fulfillment_proof = __toESM(require_fulfillment_proof());
@@ -52415,7 +52418,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
    * Derive secp256k1 public key coordinates from a private key
    */
   static derivePublicKey(privateKey) {
-    const uncompressedPubKey = import_secp256k113.secp256k1.getPublicKey(privateKey, false);
+    const uncompressedPubKey = import_secp256k114.secp256k1.getPublicKey(privateKey, false);
     const x = Array.from(uncompressedPubKey.slice(1, 33));
     const y = Array.from(uncompressedPubKey.slice(33, 65));
     return { x, y };
@@ -53243,7 +53246,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
     return Array.from(hash2);
   }
   getPublicKeyCoordinates(privateKey) {
-    const uncompressedPubKey = import_secp256k113.secp256k1.getPublicKey(privateKey, false);
+    const uncompressedPubKey = import_secp256k114.secp256k1.getPublicKey(privateKey, false);
     const x = Array.from(uncompressedPubKey.slice(1, 33));
     const y = Array.from(uncompressedPubKey.slice(33, 65));
     return { x, y };