@sip-protocol/sdk 0.9.0 → 0.11.0

package/dist/browser.mjs

@@ -458,7 +458,7 @@ import {
   verifyOracleSignature,
   verifyOwnership,
   walletRegistry
-} from "./chunk-5EKF243P.mjs";
+} from "./chunk-L4RKPNIJ.mjs";
 import {
   DEFAULT_NETWORK_CONFIG,
   DEFAULT_PROXY_TIMEOUT,
@@ -473,7 +473,9 @@ import {
   addBlindings,
   addCommitments,
   checkEd25519StealthAddress,
+  checkEd25519StealthAddressV1,
   checkProxyAvailability,
+  checkSecp256k1StealthAddressV1,
   checkStealthAddress,
   claimStealthPayment,
   commit,
@@ -487,7 +489,10 @@ import {
   createWebhookHandler,
   decodeStealthMetaAddress,
   deriveEd25519StealthPrivateKey,
+  deriveEd25519StealthPrivateKeyV1,
+  deriveSecp256k1StealthPrivateKeyV1,
   deriveStealthPrivateKey,
+  deriveStealthPrivateKeyV1,
   detectTorPort,
   ed25519PublicKeyToNearAddress,
   ed25519PublicKeyToSolanaAddress,
@@ -545,7 +550,7 @@ import {
   verifyWebhookSignature,
   withSecureBuffer,
   withSecureBufferSync
-} from "./chunk-64AYA5F5.mjs";
+} from "./chunk-7IUKXWDN.mjs";
 import {
   Halo2Provider,
   KimchiProvider,
@@ -598,7 +603,7 @@ import {
   getExplorerUrl,
   getSolanaTokenDecimals,
   getTokenMint
-} from "./chunk-4GRJ5MAW.mjs";
+} from "./chunk-KXETSSKP.mjs";
 import "./chunk-XGB3TDIC.mjs";
 
 // src/proofs/browser.ts
@@ -2348,9 +2353,11 @@ export {
   calculateSIPComparison,
   checkAptosStealthAddress,
   checkEd25519StealthAddress,
+  checkEd25519StealthAddressV1,
   checkMobileWASMCompatibility,
   checkNEARStealthAddress,
   checkProxyAvailability,
+  checkSecp256k1StealthAddressV1,
   checkStealthAddress,
   checkSuiStealthAddress,
   claimStealthPayment,
@@ -2458,11 +2465,14 @@ export {
   defaultRegistry,
   deriveAptosStealthPrivateKey,
   deriveEd25519StealthPrivateKey,
+  deriveEd25519StealthPrivateKeyV1,
   deriveNEARChildViewingKey,
   deriveNEARStealthPrivateKey,
   deriveObliviousNullifier,
   deriveOracleId,
+  deriveSecp256k1StealthPrivateKeyV1,
   deriveStealthPrivateKey,
+  deriveStealthPrivateKeyV1,
   deriveSuiStealthPrivateKey,
   deriveTraditionalNullifier,
   deriveViewingKey,

package/dist/{chunk-64AYA5F5.mjs → chunk-7IUKXWDN.mjs}

@@ -11,21 +11,23 @@ import {
   HELIUS_DAS_PAGE_LIMIT,
   HELIUS_MAX_PAGES,
   MEMO_PROGRAM_ID,
-  SIP_MEMO_PREFIX,
+  SIP_MEMO_PREFIX_ANY,
   SOLANA_ADDRESS_MAX_LENGTH,
   SOLANA_ADDRESS_MIN_LENGTH,
   SOLANA_TOKEN_MINTS,
   VIEW_TAG_MAX,
   getExplorerUrl,
   sanitizeUrl
-} from "./chunk-4GRJ5MAW.mjs";
+} from "./chunk-KXETSSKP.mjs";
 
 // src/chains/solana/types.ts
 function parseAnnouncement(memo) {
-  if (!memo.startsWith("SIP:1:")) {
+  const versionMatch = /^SIP:([12]):/.exec(memo);
+  if (!versionMatch) {
     return null;
   }
-  const parts = memo.slice(6).split(":");
+  const version = versionMatch[1];
+  const parts = memo.slice(versionMatch[0].length).split(":");
   if (parts.length < 2) {
     return null;
   }
@@ -46,13 +48,14 @@ function parseAnnouncement(memo) {
     return null;
   }
   return {
+    version,
     ephemeralPublicKey,
     viewTag,
     stealthAddress
   };
 }
 function createAnnouncementMemo(ephemeralPublicKey, viewTag, stealthAddress) {
-  const parts = ["SIP:1", ephemeralPublicKey, viewTag];
+  const parts = ["SIP:2", ephemeralPublicKey, viewTag];
   if (stealthAddress) {
     parts.push(stealthAddress);
   }
@@ -626,16 +629,16 @@ function generateEd25519StealthAddress(recipientMetaAddress) {
     if (ephemeralScalar === 0n) {
       throw new Error("CRITICAL: Zero ephemeral scalar after reduction - investigate RNG");
     }
-    const spendingPoint = ed25519.ExtendedPoint.fromHex(spendingKeyBytes);
-    const sharedSecretPoint = spendingPoint.multiply(ephemeralScalar);
+    const viewingPoint = ed25519.ExtendedPoint.fromHex(viewingKeyBytes);
+    const sharedSecretPoint = viewingPoint.multiply(ephemeralScalar);
     const sharedSecretHash = sha256(sharedSecretPoint.toRawBytes());
     const hashScalar = bytesToBigInt(sharedSecretHash) % ED25519_ORDER;
     if (hashScalar === 0n) {
       throw new Error("CRITICAL: Zero hash scalar after reduction - investigate hash computation");
     }
     const hashTimesG = ed25519.ExtendedPoint.BASE.multiply(hashScalar);
-    const viewingPoint = ed25519.ExtendedPoint.fromHex(viewingKeyBytes);
-    const stealthPoint = viewingPoint.add(hashTimesG);
+    const spendingPoint = ed25519.ExtendedPoint.fromHex(spendingKeyBytes);
+    const stealthPoint = spendingPoint.add(hashTimesG);
     const stealthAddressBytes = stealthPoint.toRawBytes();
     const viewTag = sharedSecretHash[0];
     return {
@@ -651,6 +654,57 @@ function generateEd25519StealthAddress(recipientMetaAddress) {
   }
 }
 function deriveEd25519StealthPrivateKey(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+  validateEd25519StealthAddress(stealthAddress);
+  if (!isValidPrivateKey(spendingPrivateKey)) {
+    throw new ValidationError(
+      "must be a valid 32-byte hex string",
+      "spendingPrivateKey"
+    );
+  }
+  if (!isValidPrivateKey(viewingPrivateKey)) {
+    throw new ValidationError(
+      "must be a valid 32-byte hex string",
+      "viewingPrivateKey"
+    );
+  }
+  const spendingPrivBytes = hexToBytes(spendingPrivateKey.slice(2));
+  const viewingPrivBytes = hexToBytes(viewingPrivateKey.slice(2));
+  const ephemeralPubBytes = hexToBytes(stealthAddress.ephemeralPublicKey.slice(2));
+  try {
+    const rawViewingScalar = getEd25519Scalar(viewingPrivBytes);
+    const viewingScalar = rawViewingScalar % ED25519_ORDER;
+    if (viewingScalar === 0n) {
+      throw new Error("CRITICAL: Zero viewing scalar after reduction - investigate key derivation");
+    }
+    const ephemeralPoint = ed25519.ExtendedPoint.fromHex(ephemeralPubBytes);
+    const sharedSecretPoint = ephemeralPoint.multiply(viewingScalar);
+    const sharedSecretHash = sha256(sharedSecretPoint.toRawBytes());
+    const rawSpendingScalar = getEd25519Scalar(spendingPrivBytes);
+    const spendingScalar = rawSpendingScalar % ED25519_ORDER;
+    if (spendingScalar === 0n) {
+      throw new Error("CRITICAL: Zero spending scalar after reduction - investigate key derivation");
+    }
+    const hashScalar = bytesToBigInt(sharedSecretHash) % ED25519_ORDER;
+    if (hashScalar === 0n) {
+      throw new Error("CRITICAL: Zero hash scalar after reduction - investigate hash computation");
+    }
+    const stealthPrivateScalar = (spendingScalar + hashScalar) % ED25519_ORDER;
+    if (stealthPrivateScalar === 0n) {
+      throw new Error("CRITICAL: Zero stealth scalar after reduction - investigate key derivation");
+    }
+    const stealthPrivateKey = bigIntToBytesLE(stealthPrivateScalar, 32);
+    const result = {
+      stealthAddress: stealthAddress.address,
+      ephemeralPublicKey: stealthAddress.ephemeralPublicKey,
+      privateKey: `0x${bytesToHex(stealthPrivateKey)}`
+    };
+    secureWipe(stealthPrivateKey);
+    return result;
+  } finally {
+    secureWipeAll(spendingPrivBytes, viewingPrivBytes);
+  }
+}
+function deriveEd25519StealthPrivateKeyV1(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
   validateEd25519StealthAddress(stealthAddress);
   if (!isValidPrivateKey(spendingPrivateKey)) {
     throw new ValidationError(
@@ -701,7 +755,50 @@ function deriveEd25519StealthPrivateKey(stealthAddress, spendingPrivateKey, view
     secureWipeAll(spendingPrivBytes, viewingPrivBytes);
   }
 }
-function checkEd25519StealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+function checkEd25519StealthAddress(stealthAddress, viewingPrivateKey, spendingPublicKey) {
+  validateEd25519StealthAddress(stealthAddress);
+  if (!isValidPrivateKey(viewingPrivateKey)) {
+    throw new ValidationError(
+      "must be a valid 32-byte hex string",
+      "viewingPrivateKey"
+    );
+  }
+  if (!isValidEd25519PublicKey(spendingPublicKey)) {
+    throw new ValidationError(
+      "must be a valid ed25519 public key (32 bytes)",
+      "spendingPublicKey"
+    );
+  }
+  const viewingPrivBytes = hexToBytes(viewingPrivateKey.slice(2));
+  const spendingPubBytes = hexToBytes(spendingPublicKey.slice(2));
+  const ephemeralPubBytes = hexToBytes(stealthAddress.ephemeralPublicKey.slice(2));
+  try {
+    const rawViewingScalar = getEd25519Scalar(viewingPrivBytes);
+    const viewingScalar = rawViewingScalar % ED25519_ORDER;
+    if (viewingScalar === 0n) {
+      throw new Error("CRITICAL: Zero viewing scalar after reduction - investigate key derivation");
+    }
+    const ephemeralPoint = ed25519.ExtendedPoint.fromHex(ephemeralPubBytes);
+    const sharedSecretPoint = ephemeralPoint.multiply(viewingScalar);
+    const sharedSecretHash = sha256(sharedSecretPoint.toRawBytes());
+    if (sharedSecretHash[0] !== stealthAddress.viewTag) {
+      return false;
+    }
+    const hashScalar = bytesToBigInt(sharedSecretHash) % ED25519_ORDER;
+    if (hashScalar === 0n) {
+      throw new Error("CRITICAL: Zero hash scalar after reduction - investigate hash computation");
+    }
+    const hashTimesG = ed25519.ExtendedPoint.BASE.multiply(hashScalar);
+    const spendingPoint = ed25519.ExtendedPoint.fromHex(spendingPubBytes);
+    const expectedPoint = spendingPoint.add(hashTimesG);
+    const expectedPubKeyBytes = expectedPoint.toRawBytes();
+    const providedAddress = hexToBytes(stealthAddress.address.slice(2));
+    return bytesToHex(expectedPubKeyBytes) === bytesToHex(providedAddress);
+  } finally {
+    secureWipe(viewingPrivBytes);
+  }
+}
+function checkEd25519StealthAddressV1(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
   validateEd25519StealthAddress(stealthAddress);
   if (!isValidPrivateKey(spendingPrivateKey)) {
     throw new ValidationError(
@@ -830,13 +927,16 @@ function generateSecp256k1StealthAddress(recipientMetaAddress) {
     const viewingKeyBytes = hexToBytes(recipientMetaAddress.viewingKey.slice(2));
     const sharedSecretPoint = secp256k1.getSharedSecret(
       ephemeralPrivateKey,
-      spendingKeyBytes
+      viewingKeyBytes
     );
     const sharedSecretHash = sha256(sharedSecretPoint);
-    const hashTimesG = secp256k1.getPublicKey(sharedSecretHash, true);
-    const viewingKeyPoint = secp256k1.ProjectivePoint.fromHex(viewingKeyBytes);
-    const hashTimesGPoint = secp256k1.ProjectivePoint.fromHex(hashTimesG);
-    const stealthPoint = viewingKeyPoint.add(hashTimesGPoint);
+    const hashScalar = bytesToBigInt(sharedSecretHash) % secp256k1.CURVE.n;
+    if (hashScalar === 0n) {
+      throw new Error("CRITICAL: zero hash scalar after reduction - investigate hash computation");
+    }
+    const spendingKeyPoint = secp256k1.ProjectivePoint.fromHex(spendingKeyBytes);
+    const hashTimesGPoint = secp256k1.ProjectivePoint.BASE.multiply(hashScalar);
+    const stealthPoint = spendingKeyPoint.add(hashTimesGPoint);
     const stealthAddressBytes = stealthPoint.toRawBytes(true);
     const viewTag = sharedSecretHash[0];
     return {
@@ -852,6 +952,44 @@ function generateSecp256k1StealthAddress(recipientMetaAddress) {
   }
 }
 function deriveSecp256k1StealthPrivateKey(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+  validateSecp256k1StealthAddress(stealthAddress);
+  if (!isValidPrivateKey(spendingPrivateKey)) {
+    throw new ValidationError(
+      "must be a valid 32-byte hex string",
+      "spendingPrivateKey"
+    );
+  }
+  if (!isValidPrivateKey(viewingPrivateKey)) {
+    throw new ValidationError(
+      "must be a valid 32-byte hex string",
+      "viewingPrivateKey"
+    );
+  }
+  const spendingPrivBytes = hexToBytes(spendingPrivateKey.slice(2));
+  const viewingPrivBytes = hexToBytes(viewingPrivateKey.slice(2));
+  const ephemeralPubBytes = hexToBytes(stealthAddress.ephemeralPublicKey.slice(2));
+  try {
+    const sharedSecretPoint = secp256k1.getSharedSecret(
+      viewingPrivBytes,
+      ephemeralPubBytes
+    );
+    const sharedSecretHash = sha256(sharedSecretPoint);
+    const spendingScalar = bytesToBigInt(spendingPrivBytes);
+    const hashScalar = bytesToBigInt(sharedSecretHash);
+    const stealthPrivateScalar = (spendingScalar + hashScalar) % secp256k1.CURVE.n;
+    const stealthPrivateKey = bigIntToBytes(stealthPrivateScalar, 32);
+    const result = {
+      stealthAddress: stealthAddress.address,
+      ephemeralPublicKey: stealthAddress.ephemeralPublicKey,
+      privateKey: `0x${bytesToHex(stealthPrivateKey)}`
+    };
+    secureWipe(stealthPrivateKey);
+    return result;
+  } finally {
+    secureWipeAll(spendingPrivBytes, viewingPrivBytes);
+  }
+}
+function deriveSecp256k1StealthPrivateKeyV1(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
   validateSecp256k1StealthAddress(stealthAddress);
   if (!isValidPrivateKey(spendingPrivateKey)) {
     throw new ValidationError(
@@ -889,7 +1027,46 @@ function deriveSecp256k1StealthPrivateKey(stealthAddress, spendingPrivateKey, vi
     secureWipeAll(spendingPrivBytes, viewingPrivBytes);
   }
 }
-function checkSecp256k1StealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+function checkSecp256k1StealthAddress(stealthAddress, viewingPrivateKey, spendingPublicKey) {
+  validateSecp256k1StealthAddress(stealthAddress);
+  if (!isValidPrivateKey(viewingPrivateKey)) {
+    throw new ValidationError(
+      "must be a valid 32-byte hex string",
+      "viewingPrivateKey"
+    );
+  }
+  if (!isValidCompressedPublicKey(spendingPublicKey)) {
+    throw new ValidationError(
+      "must be a valid compressed secp256k1 public key (33 bytes, starting with 02 or 03)",
+      "spendingPublicKey"
+    );
+  }
+  const viewingPrivBytes = hexToBytes(viewingPrivateKey.slice(2));
+  const spendingPubBytes = hexToBytes(spendingPublicKey.slice(2));
+  const ephemeralPubBytes = hexToBytes(stealthAddress.ephemeralPublicKey.slice(2));
+  try {
+    const sharedSecretPoint = secp256k1.getSharedSecret(
+      viewingPrivBytes,
+      ephemeralPubBytes
+    );
+    const sharedSecretHash = sha256(sharedSecretPoint);
+    if (sharedSecretHash[0] !== stealthAddress.viewTag) {
+      return false;
+    }
+    const hashScalar = bytesToBigInt(sharedSecretHash) % secp256k1.CURVE.n;
+    if (hashScalar === 0n) {
+      return false;
+    }
+    const expectedPoint = secp256k1.ProjectivePoint.fromHex(spendingPubBytes).add(
+      secp256k1.ProjectivePoint.BASE.multiply(hashScalar)
+    );
+    const providedAddress = hexToBytes(stealthAddress.address.slice(2));
+    return bytesToHex(expectedPoint.toRawBytes(true)) === bytesToHex(providedAddress);
+  } finally {
+    secureWipe(viewingPrivBytes);
+  }
+}
+function checkSecp256k1StealthAddressV1(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
   validateSecp256k1StealthAddress(stealthAddress);
   if (!isValidPrivateKey(spendingPrivateKey)) {
     throw new ValidationError(
@@ -1213,12 +1390,19 @@ function deriveStealthPrivateKey(stealthAddress, spendingPrivateKey, viewingPriv
   }
   return deriveSecp256k1StealthPrivateKey(stealthAddress, spendingPrivateKey, viewingPrivateKey);
 }
-function checkStealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+function deriveStealthPrivateKeyV1(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+  const addressHex = stealthAddress.address.slice(2);
+  if (addressHex.length === 64) {
+    return deriveEd25519StealthPrivateKeyV1(stealthAddress, spendingPrivateKey, viewingPrivateKey);
+  }
+  return deriveSecp256k1StealthPrivateKeyV1(stealthAddress, spendingPrivateKey, viewingPrivateKey);
+}
+function checkStealthAddress(stealthAddress, viewingPrivateKey, spendingPublicKey) {
   const addressHex = stealthAddress.address.slice(2);
   if (addressHex.length === 64) {
-    return checkEd25519StealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey);
+    return checkEd25519StealthAddress(stealthAddress, viewingPrivateKey, spendingPublicKey);
   }
-  return checkSecp256k1StealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey);
+  return checkSecp256k1StealthAddress(stealthAddress, viewingPrivateKey, spendingPublicKey);
 }
 
 // src/chains/solana/transfer.ts
@@ -2281,7 +2465,7 @@ async function scanForPayments(params) {
         });
         if (!tx?.meta?.logMessages) continue;
         for (const log of tx.meta.logMessages) {
-          if (!log.includes(SIP_MEMO_PREFIX)) continue;
+          if (!log.includes(SIP_MEMO_PREFIX_ANY)) continue;
           const memoMatch = log.match(/Program log: (.+)/);
           if (!memoMatch) continue;
           const memoContent = memoMatch[1];
@@ -2371,7 +2555,8 @@ async function claimStealthPayment(params) {
     viewingPrivateKey,
     spendingPrivateKey,
     destinationAddress,
-    mint
+    mint,
+    version = "2"
   } = params;
   const stealthPubkeyForBalance = new PublicKey4(stealthAddress);
   const solBalance = await connection.getBalance(stealthPubkeyForBalance);
@@ -2388,17 +2573,13 @@ async function claimStealthPayment(params) {
     viewTag: 0
     // Not needed for derivation
   };
-  const recovery = deriveEd25519StealthPrivateKey(
-    stealthAddressObj,
-    spendingPrivateKey,
-    viewingPrivateKey
-  );
+  const recovery = version === "1" ? deriveEd25519StealthPrivateKeyV1(stealthAddressObj, spendingPrivateKey, viewingPrivateKey) : deriveEd25519StealthPrivateKey(stealthAddressObj, spendingPrivateKey, viewingPrivateKey);
   const stealthPrivKeyBytes = hexToBytes2(recovery.privateKey.slice(2));
   const stealthPubkey = new PublicKey4(stealthAddress);
   const expectedPubKeyBytes = stealthPubkey.toBytes();
   const scalarBigInt = bytesToBigIntLE2(stealthPrivKeyBytes);
-  const ED25519_ORDER4 = 2n ** 252n + 27742317777372353535851937790883648493n;
-  let validScalar = scalarBigInt % ED25519_ORDER4;
+  const ED25519_ORDER3 = 2n ** 252n + 27742317777372353535851937790883648493n;
+  let validScalar = scalarBigInt % ED25519_ORDER3;
   if (validScalar === 0n) validScalar = 1n;
   const derivedPubKeyBytes = ed255192.ExtendedPoint.BASE.multiply(validScalar).toRawBytes();
   if (!derivedPubKeyBytes.every((b, i) => b === expectedPubKeyBytes[i])) {
@@ -2583,7 +2764,7 @@ var StealthScanner = class {
           });
           if (!tx?.meta?.logMessages) continue;
           for (const log of tx.meta.logMessages) {
-            if (!log.includes(SIP_MEMO_PREFIX)) continue;
+            if (!log.includes(SIP_MEMO_PREFIX_ANY)) continue;
             const memoMatch = log.match(/Program log: (.+)/);
             if (!memoMatch) continue;
             const announcement = parseAnnouncement(memoMatch[1]);
@@ -2636,7 +2817,7 @@ var StealthScanner = class {
       async (logs) => {
         try {
           for (const log of logs.logs) {
-            if (!log.includes(SIP_MEMO_PREFIX)) continue;
+            if (!log.includes(SIP_MEMO_PREFIX_ANY)) continue;
             const memoMatch = log.match(/Program log: (.+)/);
             if (!memoMatch) continue;
             const announcement = parseAnnouncement(memoMatch[1]);
@@ -2832,26 +3013,6 @@ function generateManagedEphemeralKeypair() {
         secureWipe(privateKeyBytes);
         disposed = true;
       }
-    },
-    useForStealthAddress(recipientSpendingKey, recipientViewingKey) {
-      if (disposed) {
-        throw new Error("Ephemeral keypair has been disposed");
-      }
-      try {
-        const result = computeStealthAddress(
-          privateKeyBytes,
-          publicKeyBytes,
-          recipientSpendingKey,
-          recipientViewingKey
-        );
-        return {
-          ...result,
-          ephemeralPublicKey: publicKeyHex,
-          ephemeralPublicKeyBase58: publicKeyBase58
-        };
-      } finally {
-        managed.dispose();
-      }
     }
   };
   return managed;
@@ -2909,89 +3070,6 @@ function wipeEphemeralPrivateKey(privateKeyHex) {
   const bytes = hexToBytes3(privateKeyHex.slice(2));
   secureWipe(bytes);
 }
-var ED25519_ORDER2 = 2n ** 252n + 27742317777372353535851937790883648493n;
-function bytesToBigIntLE3(bytes) {
-  let result = 0n;
-  for (let i = bytes.length - 1; i >= 0; i--) {
-    result = result << 8n | BigInt(bytes[i]);
-  }
-  return result;
-}
-function getEd25519Scalar2(privateKey) {
-  const hash = sha2562(privateKey);
-  hash[0] &= 248;
-  hash[31] &= 127;
-  hash[31] |= 64;
-  return bytesToBigIntLE3(hash.slice(0, 32));
-}
-function computeStealthAddress(ephemeralPrivateBytes, _ephemeralPublicBytes, recipientSpendingKey, recipientViewingKey) {
-  const spendingKeyBytes = hexToBytes3(recipientSpendingKey.slice(2));
-  const viewingKeyBytes = hexToBytes3(recipientViewingKey.slice(2));
-  const rawEphemeralScalar = getEd25519Scalar2(ephemeralPrivateBytes);
-  const ephemeralScalar = rawEphemeralScalar % ED25519_ORDER2;
-  if (ephemeralScalar === 0n) {
-    throw new Error("Invalid ephemeral scalar");
-  }
-  const spendingPoint = ed255193.ExtendedPoint.fromHex(spendingKeyBytes);
-  const sharedSecretPoint = spendingPoint.multiply(ephemeralScalar);
-  const sharedSecretBytes = sharedSecretPoint.toRawBytes();
-  const sharedSecretHash = sha2562(sharedSecretBytes);
-  const viewTag = sharedSecretHash[0];
-  const hashScalar = bytesToBigIntLE3(sharedSecretHash) % ED25519_ORDER2;
-  if (hashScalar === 0n) {
-    throw new Error("Invalid hash scalar");
-  }
-  const hashTimesG = ed255193.ExtendedPoint.BASE.multiply(hashScalar);
-  const viewingPoint = ed255193.ExtendedPoint.fromHex(viewingKeyBytes);
-  const stealthPoint = viewingPoint.add(hashTimesG);
-  const stealthAddressBytes = stealthPoint.toRawBytes();
-  const stealthAddress = `0x${bytesToHex2(stealthAddressBytes)}`;
-  const stealthAddressBase58 = ed25519PublicKeyToSolanaAddress(stealthAddress);
-  return {
-    sharedSecret: `0x${bytesToHex2(sharedSecretHash)}`,
-    viewTag,
-    stealthAddress,
-    stealthAddressBase58
-  };
-}
-function formatEphemeralAnnouncement(ephemeralPublicKeyBase58, viewTag, stealthAddressBase58) {
-  const viewTagHex = viewTag.toString(16).padStart(2, "0");
-  const parts = ["SIP:1", ephemeralPublicKeyBase58, viewTagHex];
-  if (stealthAddressBase58) {
-    parts.push(stealthAddressBase58);
-  }
-  return parts.join(":");
-}
-function parseEphemeralAnnouncement(announcement) {
-  if (!announcement.startsWith("SIP:1:")) {
-    return null;
-  }
-  const parts = announcement.slice(6).split(":");
-  if (parts.length < 2) {
-    return null;
-  }
-  const ephemeralPublicKeyBase58 = parts[0];
-  const viewTagHex = parts[1];
-  const stealthAddressBase58 = parts[2];
-  if (!ephemeralPublicKeyBase58 || ephemeralPublicKeyBase58.length < 32 || ephemeralPublicKeyBase58.length > 44) {
-    return null;
-  }
-  if (!viewTagHex || viewTagHex.length > 2 || !/^[0-9a-fA-F]+$/.test(viewTagHex)) {
-    return null;
-  }
-  const viewTag = parseInt(viewTagHex, 16);
-  if (viewTag < 0 || viewTag > 255) {
-    return null;
-  }
-  if (stealthAddressBase58 && (stealthAddressBase58.length < 32 || stealthAddressBase58.length > 44)) {
-    return null;
-  }
-  return {
-    ephemeralPublicKeyBase58,
-    viewTag,
-    stealthAddressBase58
-  };
-}
 
 // src/chains/solana/privacy-adapter.ts
 import { PublicKey as PublicKey9 } from "@solana/web3.js";
@@ -4059,7 +4137,7 @@ async function processRawTransaction(tx, viewingPrivateKey, spendingPublicKey, o
     return { found: false, signature };
   }
   for (const log of tx.meta.logMessages) {
-    if (!log.includes(SIP_MEMO_PREFIX)) continue;
+    if (!log.includes(SIP_MEMO_PREFIX_ANY)) continue;
     const memoMatch = log.match(/Program log: (.+)/);
     if (!memoMatch) continue;
     const memoContent = memoMatch[1];
@@ -4350,7 +4428,7 @@ var HeliusEnhanced = class {
    * Extract SIP metadata from a transaction
    *
    * Parses memo program instructions to find SIP announcements.
-   * SIP memo format: SIP:1:<ephemeral_pubkey_base58>:<view_tag_hex>
+   * SIP memo format: SIP:<version>:<ephemeral_pubkey_base58>:<view_tag_hex>
    *
    * @param tx - Enhanced transaction
    * @returns SIP metadata if found
@@ -4361,9 +4439,9 @@ var HeliusEnhanced = class {
       isSIPTransaction: false
     };
     const description = tx.description || "";
-    if (description.includes(SIP_MEMO_PREFIX) || description.includes("SIP:")) {
+    if (description.includes(SIP_MEMO_PREFIX_ANY)) {
       metadata.isSIPTransaction = true;
-      const sipMemoMatch = description.match(/SIP:1:([A-Za-z0-9]{32,44}):([0-9a-fA-F]{2})/);
+      const sipMemoMatch = description.match(/SIP:[12]:([A-Za-z0-9]{32,44}):([0-9a-fA-F]{1,2})/);
       if (sipMemoMatch) {
         metadata.ephemeralPubKey = sipMemoMatch[1];
         metadata.viewTag = parseInt(sipMemoMatch[2], 16);
@@ -5006,7 +5084,7 @@ import { sha256 as sha2565 } from "@noble/hashes/sha2";
 import { bytesToHex as bytesToHex4, randomBytes as randomBytes5 } from "@noble/hashes/utils";
 var H_DOMAIN = "SIP-SOLANA-PEDERSEN-GENERATOR-H-v1";
 var G = ed255195.ExtendedPoint.BASE;
-var ED25519_ORDER3 = 2n ** 252n + 27742317777372353535851937790883648493n;
+var ED25519_ORDER2 = 2n ** 252n + 27742317777372353535851937790883648493n;
 var ED25519_COFACTOR = 8n;
 var MAX_SPL_AMOUNT = 2n ** 64n - 1n;
 var H = generateH();
@@ -5042,18 +5120,18 @@ function commitSolana(value, blinding) {
   if (value < 0n) {
     throw new ValidationError("must be non-negative", "value");
   }
-  if (value >= ED25519_ORDER3) {
+  if (value >= ED25519_ORDER2) {
     throw new ValidationError(
       "must be less than curve order",
       "value",
-      { curveOrder: ED25519_ORDER3.toString(16) }
+      { curveOrder: ED25519_ORDER2.toString(16) }
     );
   }
   const r = blinding ?? randomBytes5(32);
   if (r.length !== 32) {
     throw new ValidationError("must be 32 bytes", "blinding", { received: r.length });
   }
-  const rScalar = bytesToBigInt2(r) % ED25519_ORDER3;
+  const rScalar = bytesToBigInt2(r) % ED25519_ORDER2;
   if (rScalar === 0n) {
     return commitSolana(value, randomBytes5(32));
   }
@@ -5076,7 +5154,7 @@ function verifyOpeningSolana(commitment, value, blinding) {
     const commitmentBytes = hexToBytes4(commitment.slice(2));
     const C = ed255195.ExtendedPoint.fromHex(commitmentBytes);
     const blindingBytes = hexToBytes4(blinding.slice(2));
-    const rScalar = bytesToBigInt2(blindingBytes) % ED25519_ORDER3;
+    const rScalar = bytesToBigInt2(blindingBytes) % ED25519_ORDER2;
     let expected;
     if (value === 0n) {
       expected = H.multiply(rScalar);
@@ -5189,14 +5267,14 @@ function subtractCommitmentsSolana(c1, c2) {
 function addBlindingsSolana(b1, b2) {
   const r1 = bytesToBigInt2(hexToBytes4(b1.slice(2)));
   const r2 = bytesToBigInt2(hexToBytes4(b2.slice(2)));
-  const sum = (r1 + r2) % ED25519_ORDER3;
+  const sum = (r1 + r2) % ED25519_ORDER2;
   const sumBytes = bigIntToBytes2(sum, 32);
   return `0x${bytesToHex4(sumBytes)}`;
 }
 function subtractBlindingsSolana(b1, b2) {
   const r1 = bytesToBigInt2(hexToBytes4(b1.slice(2)));
   const r2 = bytesToBigInt2(hexToBytes4(b2.slice(2)));
-  const diff = (r1 - r2 + ED25519_ORDER3) % ED25519_ORDER3;
+  const diff = (r1 - r2 + ED25519_ORDER2) % ED25519_ORDER2;
   const diffBytes = bigIntToBytes2(diff, 32);
   return `0x${bytesToHex4(diffBytes)}`;
 }
@@ -5805,7 +5883,7 @@ async function createProxyAgent(config, options = {}) {
   const parsed = parseProxyConfig(config === "tor" ? `socks5://${TOR_HOST}:${TOR_PORTS[0]}` : config);
   try {
     if (parsed.type === "socks5" || parsed.type === "socks4" || config === "tor") {
-      const { SocksProxyAgent } = await import("./dist-2OGQ7FED.mjs");
+      const { SocksProxyAgent } = await import("./dist-PYEXZNFD.mjs");
       return new SocksProxyAgent(proxyUrl, { timeout });
     }
     if (parsed.type === "http" || parsed.type === "https") {
@@ -7665,7 +7743,11 @@ export {
   generateEd25519StealthMetaAddress,
   generateEd25519StealthAddress,
   deriveEd25519StealthPrivateKey,
+  deriveEd25519StealthPrivateKeyV1,
   checkEd25519StealthAddress,
+  checkEd25519StealthAddressV1,
+  deriveSecp256k1StealthPrivateKeyV1,
+  checkSecp256k1StealthAddressV1,
   publicKeyToEthAddress,
   encodeStealthMetaAddress,
   decodeStealthMetaAddress,
@@ -7680,6 +7762,7 @@ export {
   generateStealthMetaAddress,
   generateStealthAddress,
   deriveStealthPrivateKey,
+  deriveStealthPrivateKeyV1,
   checkStealthAddress,
   commit,
   verifyOpening,
@@ -7727,8 +7810,6 @@ export {
   batchGenerateManagedEphemeralKeypairs,
   disposeEphemeralKeypairs,
   wipeEphemeralPrivateKey,
-  formatEphemeralAnnouncement,
-  parseEphemeralAnnouncement,
   HeliusProvider,
   GenericProvider,
   createProvider,
@@ -7748,7 +7829,7 @@ export {
   generateMnemonic,
   isValidMnemonic,
   getDerivationPath,
-  ED25519_ORDER3 as ED25519_ORDER,
+  ED25519_ORDER2 as ED25519_ORDER,
   MAX_SPL_AMOUNT,
   commitSolana,
   verifyOpeningSolana,