@sip-protocol/sdk 0.6.26 → 0.7.1

package/dist/{chunk-EMOAOF5P.mjs → chunk-SN4ZDTVW.mjs}

@@ -1,1089 +1,81 @@
 import {
-  CryptoError,
-  IntentError,
-  NetworkError,
-  ProofError,
-  ProofGenerationError,
-  SIPError,
-  ValidationError
-} from "./chunk-HGU6HZRC.mjs";
-
-// src/sip.ts
-import {
-  PrivacyLevel as PrivacyLevel2,
-  IntentStatus as IntentStatus2,
-  OneClickSwapStatus as OneClickSwapStatus3
-} from "@sip-protocol/types";
-
-// src/intent.ts
-import {
-  SIP_VERSION,
-  IntentStatus,
-  PrivacyLevel as PrivacyLevelEnum
-} from "@sip-protocol/types";
-
-// src/stealth.ts
-import { secp256k1 } from "@noble/curves/secp256k1";
-import { ed25519 } from "@noble/curves/ed25519";
-import { sha256 } from "@noble/hashes/sha256";
-import { sha512 } from "@noble/hashes/sha512";
-import { keccak_256 } from "@noble/hashes/sha3";
-import { bytesToHex, hexToBytes, randomBytes as randomBytes2 } from "@noble/hashes/utils";
-
-// src/validation.ts
-var VALID_CHAIN_IDS = [
-  "solana",
-  "ethereum",
-  "near",
-  "zcash",
-  "polygon",
-  "arbitrum",
-  "optimism",
-  "base",
-  "bitcoin",
-  "aptos",
-  "sui",
-  "cosmos",
-  "osmosis",
-  "injective",
-  "celestia",
-  "sei",
-  "dydx"
-];
-function isValidChainId(chain) {
-  return VALID_CHAIN_IDS.includes(chain);
-}
-function isValidPrivacyLevel(level) {
-  if (typeof level !== "string") return false;
-  return ["transparent", "shielded", "compliant"].includes(level);
-}
-function isValidHex(value) {
-  if (typeof value !== "string") return false;
-  if (!value.startsWith("0x")) return false;
-  const hex = value.slice(2);
-  if (hex.length === 0) return false;
-  return /^[0-9a-fA-F]+$/.test(hex);
-}
-function isValidHexLength(value, byteLength) {
-  if (!isValidHex(value)) return false;
-  const hex = value.slice(2);
-  return hex.length === byteLength * 2;
-}
-function isValidAmount(value) {
-  return typeof value === "bigint" && value > 0n;
-}
-function isNonNegativeAmount(value) {
-  return typeof value === "bigint" && value >= 0n;
-}
-function isValidSlippage(value) {
-  return typeof value === "number" && !isNaN(value) && value >= 0 && value < 1;
-}
-var STEALTH_META_ADDRESS_REGEX = /^sip:[a-z]+:0x[0-9a-fA-F]{64,66}:0x[0-9a-fA-F]{64,66}$/;
-function isValidStealthMetaAddress(addr) {
-  if (typeof addr !== "string") return false;
-  return STEALTH_META_ADDRESS_REGEX.test(addr);
-}
-function isValidCompressedPublicKey(key) {
-  if (!isValidHexLength(key, 33)) return false;
-  const prefix = key.slice(2, 4);
-  return prefix === "02" || prefix === "03";
-}
-function isValidEd25519PublicKey(key) {
-  return isValidHexLength(key, 32);
-}
-function isValidPrivateKey(key) {
-  return isValidHexLength(key, 32);
-}
-function validateAsset(asset, field) {
-  if (!asset || typeof asset !== "object") {
-    throw new ValidationError("must be an object", field);
-  }
-  const a = asset;
-  if (!a.chain || !isValidChainId(a.chain)) {
-    throw new ValidationError(
-      `invalid chain '${a.chain}', must be one of: ${VALID_CHAIN_IDS.join(", ")}`,
-      `${field}.chain`
-    );
-  }
-  if (typeof a.symbol !== "string" || a.symbol.length === 0) {
-    throw new ValidationError("symbol must be a non-empty string", `${field}.symbol`);
-  }
-  if (a.address !== null && !isValidHex(a.address)) {
-    throw new ValidationError("address must be null or valid hex string", `${field}.address`);
-  }
-  if (typeof a.decimals !== "number" || !Number.isInteger(a.decimals) || a.decimals < 0) {
-    throw new ValidationError("decimals must be a non-negative integer", `${field}.decimals`);
-  }
-}
-function validateIntentInput(input, field = "input") {
-  if (!input || typeof input !== "object") {
-    throw new ValidationError("must be an object", field);
-  }
-  const i = input;
-  validateAsset(i.asset, `${field}.asset`);
-  if (!isValidAmount(i.amount)) {
-    throw new ValidationError(
-      "amount must be a positive bigint",
-      `${field}.amount`,
-      { received: typeof i.amount, value: String(i.amount) }
-    );
-  }
-}
-function validateIntentOutput(output, field = "output") {
-  if (!output || typeof output !== "object") {
-    throw new ValidationError("must be an object", field);
-  }
-  const o = output;
-  validateAsset(o.asset, `${field}.asset`);
-  if (!isNonNegativeAmount(o.minAmount)) {
-    throw new ValidationError(
-      "minAmount must be a non-negative bigint",
-      `${field}.minAmount`,
-      { received: typeof o.minAmount, value: String(o.minAmount) }
-    );
-  }
-  if (!isValidSlippage(o.maxSlippage)) {
-    throw new ValidationError(
-      "maxSlippage must be a number between 0 and 1 (exclusive)",
-      `${field}.maxSlippage`,
-      { received: o.maxSlippage }
-    );
-  }
-}
-function validateCreateIntentParams(params) {
-  if (!params || typeof params !== "object") {
-    throw new ValidationError("params must be an object");
-  }
-  const p = params;
-  if (!p.input) {
-    throw new ValidationError("input is required", "input");
-  }
-  validateIntentInput(p.input, "input");
-  if (!p.output) {
-    throw new ValidationError("output is required", "output");
-  }
-  validateIntentOutput(p.output, "output");
-  if (!p.privacy) {
-    throw new ValidationError("privacy is required", "privacy");
-  }
-  if (!isValidPrivacyLevel(p.privacy)) {
-    throw new ValidationError(
-      `invalid privacy level '${p.privacy}', must be one of: transparent, shielded, compliant`,
-      "privacy"
-    );
-  }
-  if ((p.privacy === "shielded" || p.privacy === "compliant") && p.recipientMetaAddress) {
-    if (!isValidStealthMetaAddress(p.recipientMetaAddress)) {
-      throw new ValidationError(
-        "invalid stealth meta-address format, expected: sip:<chain>:<spendingKey>:<viewingKey>",
-        "recipientMetaAddress"
-      );
-    }
-  }
-  if (p.privacy === "compliant" && !p.viewingKey) {
-    throw new ValidationError(
-      "viewingKey is required for compliant mode",
-      "viewingKey"
-    );
-  }
-  if (p.viewingKey && !isValidHex(p.viewingKey)) {
-    throw new ValidationError(
-      "viewingKey must be a valid hex string",
-      "viewingKey"
-    );
-  }
-  if (p.ttl !== void 0) {
-    if (typeof p.ttl !== "number" || !Number.isInteger(p.ttl) || p.ttl <= 0) {
-      throw new ValidationError(
-        "ttl must be a positive integer (seconds)",
-        "ttl",
-        { received: p.ttl }
-      );
-    }
-  }
-}
-function validateViewingKey(key, field = "viewingKey") {
-  if (!key || typeof key !== "string") {
-    throw new ValidationError("must be a string", field);
-  }
-  if (!isValidHex(key)) {
-    throw new ValidationError("must be a valid hex string with 0x prefix", field);
-  }
-  if (!isValidHexLength(key, 32)) {
-    throw new ValidationError("must be 32 bytes (64 hex characters)", field);
-  }
-}
-var SECP256K1_ORDER = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141n;
-function isValidScalar(value) {
-  return value > 0n && value < SECP256K1_ORDER;
-}
-function validateScalar(value, field) {
-  if (typeof value !== "bigint") {
-    throw new ValidationError("must be a bigint", field);
-  }
-  if (!isValidScalar(value)) {
-    throw new ValidationError(
-      "must be in range (0, curve order)",
-      field,
-      { curveOrder: SECP256K1_ORDER.toString(16) }
-    );
-  }
-}
-function isValidEvmAddress(address) {
-  if (typeof address !== "string") return false;
-  return /^0x[0-9a-fA-F]{40}$/.test(address);
-}
-function isValidSolanaAddressFormat(address) {
-  if (typeof address !== "string") return false;
-  return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
-}
-function isValidNearAddressFormat(address) {
-  if (typeof address !== "string") return false;
-  if (/^[0-9a-f]{64}$/.test(address)) return true;
-  if (address.length < 2 || address.length > 64) return false;
-  if (!/^[a-z0-9]([a-z0-9._-]*[a-z0-9])?$/.test(address)) return false;
-  if (address.includes("..")) return false;
-  return true;
-}
-function isValidCosmosAddressFormat(address) {
-  if (typeof address !== "string") return false;
-  if (address.length < 39 || address.length > 90) return false;
-  const bech32Pattern = /^[a-z]+1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{38,}$/;
-  return bech32Pattern.test(address);
-}
-function getChainAddressType(chain) {
-  switch (chain) {
-    case "ethereum":
-    case "polygon":
-    case "arbitrum":
-    case "optimism":
-    case "base":
-      return "evm";
-    case "solana":
-      return "solana";
-    case "near":
-      return "near";
-    case "zcash":
-      return "zcash";
-    case "cosmos":
-    case "osmosis":
-    case "injective":
-    case "celestia":
-    case "sei":
-    case "dydx":
-      return "cosmos";
-    default:
-      return "unknown";
-  }
-}
-function validateAddressForChain(address, chain, field = "address") {
-  const addressType = getChainAddressType(chain);
-  switch (addressType) {
-    case "evm":
-      if (!isValidEvmAddress(address)) {
-        throw new ValidationError(
-          `Invalid address format for ${chain}. Expected EVM address (0x + 40 hex chars), got: ${address.slice(0, 20)}...`,
-          field,
-          { chain, expectedFormat: "0x...", receivedFormat: address.startsWith("0x") ? "hex but wrong length" : "not hex" }
-        );
-      }
-      break;
-    case "solana":
-      if (!isValidSolanaAddressFormat(address)) {
-        throw new ValidationError(
-          `Invalid address format for ${chain}. Expected Solana address (base58, 32-44 chars), got: ${address.slice(0, 20)}...`,
-          field,
-          { chain, expectedFormat: "base58", receivedFormat: address.startsWith("0x") ? "looks like EVM" : "unknown" }
-        );
-      }
-      break;
-    case "near":
-      if (!isValidNearAddressFormat(address)) {
-        throw new ValidationError(
-          `Invalid address format for ${chain}. Expected NEAR account ID (named or implicit), got: ${address.slice(0, 20)}...`,
-          field,
-          { chain, expectedFormat: "alice.near or 64 hex chars" }
-        );
-      }
-      break;
-    case "zcash":
-      if (!address || address.length === 0) {
-        throw new ValidationError(
-          `Invalid address format for ${chain}. Expected Zcash address.`,
-          field,
-          { chain }
-        );
-      }
-      break;
-    case "cosmos":
-      if (!isValidCosmosAddressFormat(address)) {
-        throw new ValidationError(
-          `Invalid address format for ${chain}. Expected Cosmos bech32 address, got: ${address.slice(0, 20)}...`,
-          field,
-          { chain, expectedFormat: "bech32" }
-        );
-      }
-      break;
-    default:
-      break;
-  }
-}
-function isAddressValidForChain(address, chain) {
-  try {
-    validateAddressForChain(address, chain);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/secure-memory.ts
-import { randomBytes } from "@noble/hashes/utils";
-function secureWipe(buffer) {
-  if (!buffer || buffer.length === 0) {
-    return;
-  }
-  const random = randomBytes(buffer.length);
-  buffer.set(random);
-  buffer.fill(0);
-}
-async function withSecureBuffer(createSecret, useSecret) {
-  const secret = createSecret();
-  try {
-    return await useSecret(secret);
-  } finally {
-    secureWipe(secret);
-  }
-}
-function withSecureBufferSync(createSecret, useSecret) {
-  const secret = createSecret();
-  try {
-    return useSecret(secret);
-  } finally {
-    secureWipe(secret);
-  }
-}
-function secureWipeAll(...buffers) {
-  for (const buffer of buffers) {
-    if (buffer) {
-      secureWipe(buffer);
-    }
-  }
-}
-
-// src/stealth.ts
-function generateStealthMetaAddress(chain, label) {
-  if (!isValidChainId(chain)) {
-    throw new ValidationError(
-      `invalid chain '${chain}', must be one of: solana, ethereum, near, zcash, polygon, arbitrum, optimism, base, bitcoin, aptos, sui, cosmos, osmosis, injective, celestia, sei, dydx`,
-      "chain"
-    );
-  }
-  const spendingPrivateKey = randomBytes2(32);
-  const viewingPrivateKey = randomBytes2(32);
-  try {
-    const spendingKey = secp256k1.getPublicKey(spendingPrivateKey, true);
-    const viewingKey = secp256k1.getPublicKey(viewingPrivateKey, true);
-    const result = {
-      metaAddress: {
-        spendingKey: `0x${bytesToHex(spendingKey)}`,
-        viewingKey: `0x${bytesToHex(viewingKey)}`,
-        chain,
-        label
-      },
-      spendingPrivateKey: `0x${bytesToHex(spendingPrivateKey)}`,
-      viewingPrivateKey: `0x${bytesToHex(viewingPrivateKey)}`
-    };
-    return result;
-  } finally {
-    secureWipeAll(spendingPrivateKey, viewingPrivateKey);
-  }
-}
-function validateStealthMetaAddress(metaAddress, field = "recipientMetaAddress") {
-  if (!metaAddress || typeof metaAddress !== "object") {
-    throw new ValidationError("must be an object", field);
-  }
-  if (!isValidChainId(metaAddress.chain)) {
-    throw new ValidationError(
-      `invalid chain '${metaAddress.chain}'`,
-      `${field}.chain`
-    );
-  }
-  const isEd25519 = isEd25519Chain(metaAddress.chain);
-  if (isEd25519) {
-    if (!isValidEd25519PublicKey(metaAddress.spendingKey)) {
-      throw new ValidationError(
-        "spendingKey must be a valid ed25519 public key (32 bytes)",
-        `${field}.spendingKey`
-      );
-    }
-    if (!isValidEd25519PublicKey(metaAddress.viewingKey)) {
-      throw new ValidationError(
-        "viewingKey must be a valid ed25519 public key (32 bytes)",
-        `${field}.viewingKey`
-      );
-    }
-  } else {
-    if (!isValidCompressedPublicKey(metaAddress.spendingKey)) {
-      throw new ValidationError(
-        "spendingKey must be a valid compressed secp256k1 public key (33 bytes, starting with 02 or 03)",
-        `${field}.spendingKey`
-      );
-    }
-    if (!isValidCompressedPublicKey(metaAddress.viewingKey)) {
-      throw new ValidationError(
-        "viewingKey must be a valid compressed secp256k1 public key (33 bytes, starting with 02 or 03)",
-        `${field}.viewingKey`
-      );
-    }
-  }
-}
-function generateStealthAddress(recipientMetaAddress) {
-  validateStealthMetaAddress(recipientMetaAddress);
-  const ephemeralPrivateKey = randomBytes2(32);
-  try {
-    const ephemeralPublicKey = secp256k1.getPublicKey(ephemeralPrivateKey, true);
-    const spendingKeyBytes = hexToBytes(recipientMetaAddress.spendingKey.slice(2));
-    const viewingKeyBytes = hexToBytes(recipientMetaAddress.viewingKey.slice(2));
-    const sharedSecretPoint = secp256k1.getSharedSecret(
-      ephemeralPrivateKey,
-      spendingKeyBytes
-    );
-    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 stealthAddressBytes = stealthPoint.toRawBytes(true);
-    const viewTag = sharedSecretHash[0];
-    return {
-      stealthAddress: {
-        address: `0x${bytesToHex(stealthAddressBytes)}`,
-        ephemeralPublicKey: `0x${bytesToHex(ephemeralPublicKey)}`,
-        viewTag
-      },
-      sharedSecret: `0x${bytesToHex(sharedSecretHash)}`
-    };
-  } finally {
-    secureWipe(ephemeralPrivateKey);
-  }
-}
-function validateStealthAddress(stealthAddress, field = "stealthAddress") {
-  if (!stealthAddress || typeof stealthAddress !== "object") {
-    throw new ValidationError("must be an object", field);
-  }
-  if (!isValidCompressedPublicKey(stealthAddress.address)) {
-    throw new ValidationError(
-      "address must be a valid compressed secp256k1 public key",
-      `${field}.address`
-    );
-  }
-  if (!isValidCompressedPublicKey(stealthAddress.ephemeralPublicKey)) {
-    throw new ValidationError(
-      "ephemeralPublicKey must be a valid compressed secp256k1 public key",
-      `${field}.ephemeralPublicKey`
-    );
-  }
-  if (typeof stealthAddress.viewTag !== "number" || !Number.isInteger(stealthAddress.viewTag) || stealthAddress.viewTag < 0 || stealthAddress.viewTag > 255) {
-    throw new ValidationError(
-      "viewTag must be an integer between 0 and 255",
-      `${field}.viewTag`
-    );
-  }
-}
-function deriveStealthPrivateKey(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
-  validateStealthAddress(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(
-      spendingPrivBytes,
-      ephemeralPubBytes
-    );
-    const sharedSecretHash = sha256(sharedSecretPoint);
-    const viewingScalar = bytesToBigInt(viewingPrivBytes);
-    const hashScalar = bytesToBigInt(sharedSecretHash);
-    const stealthPrivateScalar = (viewingScalar + 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 checkStealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
-  validateStealthAddress(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(
-      spendingPrivBytes,
-      ephemeralPubBytes
-    );
-    const sharedSecretHash = sha256(sharedSecretPoint);
-    if (sharedSecretHash[0] !== stealthAddress.viewTag) {
-      return false;
-    }
-    const viewingScalar = bytesToBigInt(viewingPrivBytes);
-    const hashScalar = bytesToBigInt(sharedSecretHash);
-    const stealthPrivateScalar = (viewingScalar + hashScalar) % secp256k1.CURVE.n;
-    const derivedKeyBytes = bigIntToBytes(stealthPrivateScalar, 32);
-    const expectedPubKey = secp256k1.getPublicKey(derivedKeyBytes, true);
-    secureWipe(derivedKeyBytes);
-    const providedAddress = hexToBytes(stealthAddress.address.slice(2));
-    return bytesToHex(expectedPubKey) === bytesToHex(providedAddress);
-  } finally {
-    secureWipeAll(spendingPrivBytes, viewingPrivBytes);
-  }
-}
-function encodeStealthMetaAddress(metaAddress) {
-  return `sip:${metaAddress.chain}:${metaAddress.spendingKey}:${metaAddress.viewingKey}`;
-}
-function decodeStealthMetaAddress(encoded) {
-  if (typeof encoded !== "string") {
-    throw new ValidationError("must be a string", "encoded");
-  }
-  const parts = encoded.split(":");
-  if (parts.length < 4 || parts[0] !== "sip") {
-    throw new ValidationError(
-      "invalid format, expected: sip:<chain>:<spendingKey>:<viewingKey>",
-      "encoded"
-    );
-  }
-  const [, chain, spendingKey, viewingKey] = parts;
-  if (!isValidChainId(chain)) {
-    throw new ValidationError(
-      `invalid chain '${chain}'`,
-      "encoded.chain"
-    );
-  }
-  const chainId = chain;
-  if (isEd25519Chain(chainId)) {
-    if (!isValidEd25519PublicKey(spendingKey)) {
-      throw new ValidationError(
-        "spendingKey must be a valid 32-byte ed25519 public key",
-        "encoded.spendingKey"
-      );
-    }
-    if (!isValidEd25519PublicKey(viewingKey)) {
-      throw new ValidationError(
-        "viewingKey must be a valid 32-byte ed25519 public key",
-        "encoded.viewingKey"
-      );
-    }
-  } else {
-    if (!isValidCompressedPublicKey(spendingKey)) {
-      throw new ValidationError(
-        "spendingKey must be a valid compressed secp256k1 public key",
-        "encoded.spendingKey"
-      );
-    }
-    if (!isValidCompressedPublicKey(viewingKey)) {
-      throw new ValidationError(
-        "viewingKey must be a valid compressed secp256k1 public key",
-        "encoded.viewingKey"
-      );
-    }
-  }
-  return {
-    chain,
-    spendingKey,
-    viewingKey
-  };
-}
-function bytesToBigInt(bytes) {
-  let result = 0n;
-  for (const byte of bytes) {
-    result = (result << 8n) + BigInt(byte);
-  }
-  return result;
-}
-function bigIntToBytes(value, length) {
-  const bytes = new Uint8Array(length);
-  for (let i = length - 1; i >= 0; i--) {
-    bytes[i] = Number(value & 0xffn);
-    value >>= 8n;
-  }
-  return bytes;
-}
-function publicKeyToEthAddress(publicKey) {
-  const keyHex = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
-  const keyBytes = hexToBytes(keyHex);
-  let uncompressedBytes;
-  if (keyBytes.length === 33) {
-    const point = secp256k1.ProjectivePoint.fromHex(keyBytes);
-    uncompressedBytes = point.toRawBytes(false);
-  } else if (keyBytes.length === 65) {
-    uncompressedBytes = keyBytes;
-  } else {
-    throw new ValidationError(
-      `invalid public key length: ${keyBytes.length}, expected 33 (compressed) or 65 (uncompressed)`,
-      "publicKey"
-    );
-  }
-  const pubKeyWithoutPrefix = uncompressedBytes.slice(1);
-  const hash2 = keccak_256(pubKeyWithoutPrefix);
-  const addressBytes = hash2.slice(-20);
-  return toChecksumAddress(`0x${bytesToHex(addressBytes)}`);
-}
-function toChecksumAddress(address) {
-  const addr = address.toLowerCase().replace("0x", "");
-  const hash2 = bytesToHex(keccak_256(new TextEncoder().encode(addr)));
-  let checksummed = "0x";
-  for (let i = 0; i < addr.length; i++) {
-    if (parseInt(hash2[i], 16) >= 8) {
-      checksummed += addr[i].toUpperCase();
-    } else {
-      checksummed += addr[i];
-    }
-  }
-  return checksummed;
-}
-var ED25519_ORDER = 2n ** 252n + 27742317777372353535851937790883648493n;
-var ED25519_CHAINS = ["solana", "near", "aptos", "sui"];
-function isEd25519Chain(chain) {
-  return ED25519_CHAINS.includes(chain);
-}
-function getCurveForChain(chain) {
-  return isEd25519Chain(chain) ? "ed25519" : "secp256k1";
-}
-function validateEd25519StealthMetaAddress(metaAddress, field = "recipientMetaAddress") {
-  if (!metaAddress || typeof metaAddress !== "object") {
-    throw new ValidationError("must be an object", field);
-  }
-  if (!isValidChainId(metaAddress.chain)) {
-    throw new ValidationError(
-      `invalid chain '${metaAddress.chain}'`,
-      `${field}.chain`
-    );
-  }
-  if (!isEd25519Chain(metaAddress.chain)) {
-    throw new ValidationError(
-      `chain '${metaAddress.chain}' does not use ed25519, use secp256k1 functions instead`,
-      `${field}.chain`
-    );
-  }
-  if (!isValidEd25519PublicKey(metaAddress.spendingKey)) {
-    throw new ValidationError(
-      "spendingKey must be a valid ed25519 public key (32 bytes)",
-      `${field}.spendingKey`
-    );
-  }
-  if (!isValidEd25519PublicKey(metaAddress.viewingKey)) {
-    throw new ValidationError(
-      "viewingKey must be a valid ed25519 public key (32 bytes)",
-      `${field}.viewingKey`
-    );
-  }
-}
-function validateEd25519StealthAddress(stealthAddress, field = "stealthAddress") {
-  if (!stealthAddress || typeof stealthAddress !== "object") {
-    throw new ValidationError("must be an object", field);
-  }
-  if (!isValidEd25519PublicKey(stealthAddress.address)) {
-    throw new ValidationError(
-      "address must be a valid ed25519 public key (32 bytes)",
-      `${field}.address`
-    );
-  }
-  if (!isValidEd25519PublicKey(stealthAddress.ephemeralPublicKey)) {
-    throw new ValidationError(
-      "ephemeralPublicKey must be a valid ed25519 public key (32 bytes)",
-      `${field}.ephemeralPublicKey`
-    );
-  }
-  if (typeof stealthAddress.viewTag !== "number" || !Number.isInteger(stealthAddress.viewTag) || stealthAddress.viewTag < 0 || stealthAddress.viewTag > 255) {
-    throw new ValidationError(
-      "viewTag must be an integer between 0 and 255",
-      `${field}.viewTag`
-    );
-  }
-}
-function getEd25519Scalar(privateKey) {
-  const hash2 = sha512(privateKey);
-  const scalar = hash2.slice(0, 32);
-  scalar[0] &= 248;
-  scalar[31] &= 127;
-  scalar[31] |= 64;
-  return bytesToBigIntLE(scalar);
-}
-function bytesToBigIntLE(bytes) {
-  let result = 0n;
-  for (let i = bytes.length - 1; i >= 0; i--) {
-    result = (result << 8n) + BigInt(bytes[i]);
-  }
-  return result;
-}
-function bigIntToBytesLE(value, length) {
-  const bytes = new Uint8Array(length);
-  for (let i = 0; i < length; i++) {
-    bytes[i] = Number(value & 0xffn);
-    value >>= 8n;
-  }
-  return bytes;
-}
-function generateEd25519StealthMetaAddress(chain, label) {
-  if (!isValidChainId(chain)) {
-    throw new ValidationError(
-      `invalid chain '${chain}', must be one of: solana, ethereum, near, zcash, polygon, arbitrum, optimism, base, bitcoin, aptos, sui, cosmos, osmosis, injective, celestia, sei, dydx`,
-      "chain"
-    );
-  }
-  if (!isEd25519Chain(chain)) {
-    throw new ValidationError(
-      `chain '${chain}' does not use ed25519, use generateStealthMetaAddress() for secp256k1 chains`,
-      "chain"
-    );
-  }
-  const spendingPrivateKey = randomBytes2(32);
-  const viewingPrivateKey = randomBytes2(32);
-  try {
-    const spendingKey = ed25519.getPublicKey(spendingPrivateKey);
-    const viewingKey = ed25519.getPublicKey(viewingPrivateKey);
-    const result = {
-      metaAddress: {
-        spendingKey: `0x${bytesToHex(spendingKey)}`,
-        viewingKey: `0x${bytesToHex(viewingKey)}`,
-        chain,
-        label
-      },
-      spendingPrivateKey: `0x${bytesToHex(spendingPrivateKey)}`,
-      viewingPrivateKey: `0x${bytesToHex(viewingPrivateKey)}`
-    };
-    return result;
-  } finally {
-    secureWipeAll(spendingPrivateKey, viewingPrivateKey);
-  }
-}
-function generateEd25519StealthAddress(recipientMetaAddress) {
-  validateEd25519StealthMetaAddress(recipientMetaAddress);
-  const ephemeralPrivateKey = randomBytes2(32);
-  try {
-    const ephemeralPublicKey = ed25519.getPublicKey(ephemeralPrivateKey);
-    const spendingKeyBytes = hexToBytes(recipientMetaAddress.spendingKey.slice(2));
-    const viewingKeyBytes = hexToBytes(recipientMetaAddress.viewingKey.slice(2));
-    const rawEphemeralScalar = getEd25519Scalar(ephemeralPrivateKey);
-    const ephemeralScalar = rawEphemeralScalar % ED25519_ORDER;
-    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 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 stealthAddressBytes = stealthPoint.toRawBytes();
-    const viewTag = sharedSecretHash[0];
-    return {
-      stealthAddress: {
-        address: `0x${bytesToHex(stealthAddressBytes)}`,
-        ephemeralPublicKey: `0x${bytesToHex(ephemeralPublicKey)}`,
-        viewTag
-      },
-      sharedSecret: `0x${bytesToHex(sharedSecretHash)}`
-    };
-  } finally {
-    secureWipe(ephemeralPrivateKey);
-  }
-}
-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 rawSpendingScalar = getEd25519Scalar(spendingPrivBytes);
-    const spendingScalar = rawSpendingScalar % ED25519_ORDER;
-    if (spendingScalar === 0n) {
-      throw new Error("CRITICAL: Zero spending scalar after reduction - investigate key derivation");
-    }
-    const ephemeralPoint = ed25519.ExtendedPoint.fromHex(ephemeralPubBytes);
-    const sharedSecretPoint = ephemeralPoint.multiply(spendingScalar);
-    const sharedSecretHash = sha256(sharedSecretPoint.toRawBytes());
-    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 hashScalar = bytesToBigInt(sharedSecretHash) % ED25519_ORDER;
-    if (hashScalar === 0n) {
-      throw new Error("CRITICAL: Zero hash scalar after reduction - investigate hash computation");
-    }
-    const stealthPrivateScalar = (viewingScalar + 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 checkEd25519StealthAddress(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 rawSpendingScalar = getEd25519Scalar(spendingPrivBytes);
-    const spendingScalar = rawSpendingScalar % ED25519_ORDER;
-    if (spendingScalar === 0n) {
-      throw new Error("CRITICAL: Zero spending scalar after reduction - investigate key derivation");
-    }
-    const ephemeralPoint = ed25519.ExtendedPoint.fromHex(ephemeralPubBytes);
-    const sharedSecretPoint = ephemeralPoint.multiply(spendingScalar);
-    const sharedSecretHash = sha256(sharedSecretPoint.toRawBytes());
-    if (sharedSecretHash[0] !== stealthAddress.viewTag) {
-      return false;
-    }
-    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 hashScalar = bytesToBigInt(sharedSecretHash) % ED25519_ORDER;
-    if (hashScalar === 0n) {
-      throw new Error("CRITICAL: Zero hash scalar after reduction - investigate hash computation");
-    }
-    const stealthPrivateScalar = (viewingScalar + hashScalar) % ED25519_ORDER;
-    if (stealthPrivateScalar === 0n) {
-      throw new Error("CRITICAL: Zero stealth scalar after reduction - investigate key derivation");
-    }
-    const expectedPubKey = ed25519.ExtendedPoint.BASE.multiply(stealthPrivateScalar);
-    const expectedPubKeyBytes = expectedPubKey.toRawBytes();
-    const providedAddress = hexToBytes(stealthAddress.address.slice(2));
-    return bytesToHex(expectedPubKeyBytes) === bytesToHex(providedAddress);
-  } finally {
-    secureWipeAll(spendingPrivBytes, viewingPrivBytes);
-  }
-}
-var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-function bytesToBase58(bytes) {
-  let leadingZeros = 0;
-  for (let i = 0; i < bytes.length && bytes[i] === 0; i++) {
-    leadingZeros++;
-  }
-  let value = 0n;
-  for (const byte of bytes) {
-    value = value * 256n + BigInt(byte);
-  }
-  let result = "";
-  while (value > 0n) {
-    const remainder = value % 58n;
-    value = value / 58n;
-    result = BASE58_ALPHABET[Number(remainder)] + result;
-  }
-  return "1".repeat(leadingZeros) + result;
-}
-function base58ToBytes(str) {
-  let leadingOnes = 0;
-  for (let i = 0; i < str.length && str[i] === "1"; i++) {
-    leadingOnes++;
-  }
-  let value = 0n;
-  for (const char of str) {
-    const index = BASE58_ALPHABET.indexOf(char);
-    if (index === -1) {
-      throw new ValidationError(`Invalid base58 character: ${char}`, "address");
-    }
-    value = value * 58n + BigInt(index);
-  }
-  const bytes = [];
-  while (value > 0n) {
-    bytes.unshift(Number(value % 256n));
-    value = value / 256n;
-  }
-  const result = new Uint8Array(leadingOnes + bytes.length);
-  for (let i = 0; i < leadingOnes; i++) {
-    result[i] = 0;
-  }
-  for (let i = 0; i < bytes.length; i++) {
-    result[leadingOnes + i] = bytes[i];
-  }
-  return result;
-}
-function ed25519PublicKeyToSolanaAddress(publicKey) {
-  if (!isValidHex(publicKey)) {
-    throw new ValidationError(
-      "publicKey must be a valid hex string with 0x prefix",
-      "publicKey"
-    );
-  }
-  if (!isValidEd25519PublicKey(publicKey)) {
-    throw new ValidationError(
-      "publicKey must be 32 bytes (64 hex characters)",
-      "publicKey"
-    );
-  }
-  const publicKeyBytes = hexToBytes(publicKey.slice(2));
-  return bytesToBase58(publicKeyBytes);
-}
-function isValidSolanaAddress(address) {
-  if (typeof address !== "string" || address.length === 0) {
-    return false;
-  }
-  if (address.length < 32 || address.length > 44) {
-    return false;
-  }
-  try {
-    const decoded = base58ToBytes(address);
-    return decoded.length === 32;
-  } catch {
-    return false;
-  }
-}
-function solanaAddressToEd25519PublicKey(address) {
-  if (!isValidSolanaAddress(address)) {
-    throw new ValidationError(
-      "Invalid Solana address format",
-      "address"
-    );
-  }
-  const decoded = base58ToBytes(address);
-  return `0x${bytesToHex(decoded)}`;
-}
-function ed25519PublicKeyToNearAddress(publicKey) {
-  if (!isValidHex(publicKey)) {
-    throw new ValidationError(
-      "publicKey must be a valid hex string with 0x prefix",
-      "publicKey"
-    );
-  }
-  if (!isValidEd25519PublicKey(publicKey)) {
-    throw new ValidationError(
-      "publicKey must be 32 bytes (64 hex characters)",
-      "publicKey"
-    );
-  }
-  return publicKey.slice(2).toLowerCase();
-}
-function nearAddressToEd25519PublicKey(address) {
-  if (!isValidNearImplicitAddress(address)) {
-    throw new ValidationError(
-      "Invalid NEAR implicit address format",
-      "address"
-    );
-  }
-  return `0x${address.toLowerCase()}`;
-}
-function isValidNearImplicitAddress(address) {
-  if (typeof address !== "string" || address.length === 0) {
-    return false;
-  }
-  if (address.length !== 64) {
-    return false;
-  }
-  return /^[0-9a-f]{64}$/.test(address);
-}
-function isValidNearAccountId(accountId) {
-  if (typeof accountId !== "string" || accountId.length === 0) {
-    return false;
-  }
-  if (isValidNearImplicitAddress(accountId)) {
-    return true;
-  }
-  if (accountId.length < 2 || accountId.length > 64) {
-    return false;
-  }
-  const nearAccountPattern = /^[a-z0-9]([a-z0-9._-]*[a-z0-9])?$/;
-  if (!nearAccountPattern.test(accountId)) {
-    return false;
-  }
-  if (accountId.includes("..")) {
-    return false;
-  }
-  return true;
-}
+  ProofGenerationError
+} from "./chunk-HOR7PM3M.mjs";
+import {
+  checkEd25519StealthAddress,
+  checkStealthAddress,
+  decodeStealthMetaAddress,
+  deriveEd25519StealthPrivateKey,
+  deriveStealthPrivateKey,
+  ed25519PublicKeyToNearAddress,
+  ed25519PublicKeyToSolanaAddress,
+  encodeStealthMetaAddress,
+  estimatePrivateTransferFee,
+  generateEd25519StealthAddress,
+  generateStealthAddress,
+  generateStealthMetaAddress,
+  getChainAddressType,
+  isAddressValidForChain,
+  isEd25519Chain,
+  isValidAmount,
+  isValidChainId,
+  isValidEd25519PublicKey,
+  isValidHex,
+  isValidPrivacyLevel,
+  isValidPrivateKey,
+  isValidSlippage,
+  isValidStealthMetaAddress,
+  publicKeyToEthAddress,
+  secureWipe,
+  sendPrivateSPLTransfer,
+  validateCreateIntentParams
+} from "./chunk-DLDWZFYC.mjs";
+import {
+  CryptoError,
+  IntentError,
+  NetworkError,
+  ProofError,
+  SIPError,
+  ValidationError
+} from "./chunk-6WGN57S2.mjs";
+
+// src/sip.ts
+import {
+  PrivacyLevel as PrivacyLevel2,
+  IntentStatus as IntentStatus2,
+  OneClickSwapStatus as OneClickSwapStatus3
+} from "@sip-protocol/types";
+
+// src/intent.ts
+import {
+  SIP_VERSION,
+  IntentStatus,
+  PrivacyLevel as PrivacyLevelEnum
+} from "@sip-protocol/types";
 
 // src/crypto.ts
-import { sha256 as sha2563 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex3, randomBytes as randomBytes4 } from "@noble/hashes/utils";
+import { sha256 as sha2562 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex2, randomBytes as randomBytes2 } from "@noble/hashes/utils";
 
 // src/commitment.ts
-import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
-import { sha256 as sha2562 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex2, hexToBytes as hexToBytes2, randomBytes as randomBytes3 } from "@noble/hashes/utils";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex, hexToBytes, randomBytes } from "@noble/hashes/utils";
 var H_DOMAIN = "SIP-PEDERSEN-GENERATOR-H-v1";
-var G = secp256k12.ProjectivePoint.BASE;
+var G = secp256k1.ProjectivePoint.BASE;
 var H = generateH();
-var CURVE_ORDER = secp256k12.CURVE.n;
+var CURVE_ORDER = secp256k1.CURVE.n;
 function generateH() {
   let counter = 0;
   while (counter < 256) {
     const input = new TextEncoder().encode(`${H_DOMAIN}:${counter}`);
-    const hashBytes = sha2562(input);
+    const hashBytes = sha256(input);
     try {
       const pointBytes = new Uint8Array(33);
       pointBytes[0] = 2;
       pointBytes.set(hashBytes, 1);
-      const point = secp256k12.ProjectivePoint.fromHex(pointBytes);
-      if (!point.equals(secp256k12.ProjectivePoint.ZERO) && !point.equals(G)) {
+      const point = secp256k1.ProjectivePoint.fromHex(pointBytes);
+      if (!point.equals(secp256k1.ProjectivePoint.ZERO) && !point.equals(G)) {
         return point;
       }
     } catch {
@@ -1110,17 +102,17 @@ function commit(value, blinding) {
       { curveOrder: CURVE_ORDER.toString(16) }
     );
   }
-  const r = blinding ?? randomBytes3(32);
+  const r = blinding ?? randomBytes(32);
   if (r.length !== 32) {
     throw new ValidationError("must be 32 bytes", "blinding", { received: r.length });
   }
-  const rScalar = bytesToBigInt2(r) % CURVE_ORDER;
+  const rScalar = bytesToBigInt(r) % CURVE_ORDER;
   if (rScalar === 0n) {
     throw new Error("CRITICAL: Zero blinding scalar after reduction - investigate RNG");
   }
   let C;
   if (value === 0n && rScalar === 0n) {
-    C = secp256k12.ProjectivePoint.ZERO;
+    C = secp256k1.ProjectivePoint.ZERO;
   } else if (value === 0n) {
     C = H.multiply(rScalar);
   } else if (rScalar === 0n) {
@@ -1131,8 +123,8 @@ function commit(value, blinding) {
     C = vG.add(rH);
   }
   return {
-    commitment: `0x${bytesToHex2(C.toRawBytes(true))}`,
-    blinding: `0x${bytesToHex2(r)}`
+    commitment: `0x${bytesToHex(C.toRawBytes(true))}`,
+    blinding: `0x${bytesToHex(r)}`
   };
 }
 function verifyOpening(commitment, value, blinding) {
@@ -1140,9 +132,9 @@ function verifyOpening(commitment, value, blinding) {
     if (commitment === "0x00") {
       return value === 0n && blinding === "0x" + "0".repeat(64);
     }
-    const C = secp256k12.ProjectivePoint.fromHex(commitment.slice(2));
-    const blindingBytes = hexToBytes2(blinding.slice(2));
-    const rScalar = bytesToBigInt2(blindingBytes) % CURVE_ORDER;
+    const C = secp256k1.ProjectivePoint.fromHex(commitment.slice(2));
+    const blindingBytes = hexToBytes(blinding.slice(2));
+    const rScalar = bytesToBigInt(blindingBytes) % CURVE_ORDER;
     if (rScalar === 0n) {
       throw new Error("CRITICAL: Zero blinding scalar after reduction - investigate RNG");
     }
@@ -1174,18 +166,18 @@ function addCommitments(c1, c2) {
   let point1;
   let point2;
   try {
-    point1 = secp256k12.ProjectivePoint.fromHex(c1.slice(2));
+    point1 = secp256k1.ProjectivePoint.fromHex(c1.slice(2));
   } catch {
     throw new ValidationError("must be a valid curve point", "c1");
   }
   try {
-    point2 = secp256k12.ProjectivePoint.fromHex(c2.slice(2));
+    point2 = secp256k1.ProjectivePoint.fromHex(c2.slice(2));
   } catch {
     throw new ValidationError("must be a valid curve point", "c2");
   }
   const sum = point1.add(point2);
   return {
-    commitment: `0x${bytesToHex2(sum.toRawBytes(true))}`
+    commitment: `0x${bytesToHex(sum.toRawBytes(true))}`
   };
 }
 function subtractCommitments(c1, c2) {
@@ -1198,38 +190,38 @@ function subtractCommitments(c1, c2) {
   let point1;
   let point2;
   try {
-    point1 = secp256k12.ProjectivePoint.fromHex(c1.slice(2));
+    point1 = secp256k1.ProjectivePoint.fromHex(c1.slice(2));
   } catch {
     throw new ValidationError("must be a valid curve point", "c1");
   }
   try {
-    point2 = secp256k12.ProjectivePoint.fromHex(c2.slice(2));
+    point2 = secp256k1.ProjectivePoint.fromHex(c2.slice(2));
   } catch {
     throw new ValidationError("must be a valid curve point", "c2");
   }
   const diff = point1.subtract(point2);
-  if (diff.equals(secp256k12.ProjectivePoint.ZERO)) {
+  if (diff.equals(secp256k1.ProjectivePoint.ZERO)) {
     return {
       commitment: "0x00"
     };
   }
   return {
-    commitment: `0x${bytesToHex2(diff.toRawBytes(true))}`
+    commitment: `0x${bytesToHex(diff.toRawBytes(true))}`
   };
 }
 function addBlindings(b1, b2) {
-  const r1 = bytesToBigInt2(hexToBytes2(b1.slice(2)));
-  const r2 = bytesToBigInt2(hexToBytes2(b2.slice(2)));
+  const r1 = bytesToBigInt(hexToBytes(b1.slice(2)));
+  const r2 = bytesToBigInt(hexToBytes(b2.slice(2)));
   const sum = (r1 + r2) % CURVE_ORDER;
-  const sumBytes = bigIntToBytes2(sum, 32);
-  return `0x${bytesToHex2(sumBytes)}`;
+  const sumBytes = bigIntToBytes(sum, 32);
+  return `0x${bytesToHex(sumBytes)}`;
 }
 function subtractBlindings(b1, b2) {
-  const r1 = bytesToBigInt2(hexToBytes2(b1.slice(2)));
-  const r2 = bytesToBigInt2(hexToBytes2(b2.slice(2)));
+  const r1 = bytesToBigInt(hexToBytes(b1.slice(2)));
+  const r2 = bytesToBigInt(hexToBytes(b2.slice(2)));
   const diff = (r1 - r2 + CURVE_ORDER) % CURVE_ORDER;
-  const diffBytes = bigIntToBytes2(diff, 32);
-  return `0x${bytesToHex2(diffBytes)}`;
+  const diffBytes = bigIntToBytes(diff, 32);
+  return `0x${bytesToHex(diffBytes)}`;
 }
 function getGenerators() {
   const gAffine = G.toAffine();
@@ -1246,16 +238,16 @@ function getGenerators() {
   };
 }
 function generateBlinding() {
-  return `0x${bytesToHex2(randomBytes3(32))}`;
+  return `0x${bytesToHex(randomBytes(32))}`;
 }
-function bytesToBigInt2(bytes) {
+function bytesToBigInt(bytes) {
   let result = 0n;
   for (const byte of bytes) {
     result = (result << 8n) + BigInt(byte);
   }
   return result;
 }
-function bigIntToBytes2(value, length) {
+function bigIntToBytes(value, length) {
   const bytes = new Uint8Array(length);
   let v = value;
   for (let i = length - 1; i >= 0; i--) {
@@ -1291,27 +283,27 @@ function verifyCommitment(commitment, expectedValue) {
   return verifyOpening(commitment.value, expectedValue, commitment.blindingFactor);
 }
 function generateIntentId() {
-  const bytes = randomBytes4(16);
-  return `sip-${bytesToHex3(bytes)}`;
+  const bytes = randomBytes2(16);
+  return `sip-${bytesToHex2(bytes)}`;
 }
 function hash(data) {
   const input = typeof data === "string" ? new TextEncoder().encode(data) : data;
-  return `0x${bytesToHex3(sha2563(input))}`;
+  return `0x${bytesToHex2(sha2562(input))}`;
 }
 function generateRandomBytes(length) {
-  return `0x${bytesToHex3(randomBytes4(length))}`;
+  return `0x${bytesToHex2(randomBytes2(length))}`;
 }
 
 // src/intent.ts
-import { hexToBytes as hexToBytes4, bytesToHex as bytesToHex5, randomBytes as randomBytes6 } from "@noble/hashes/utils";
-import { sha256 as sha2565 } from "@noble/hashes/sha256";
+import { hexToBytes as hexToBytes3, bytesToHex as bytesToHex4, randomBytes as randomBytes4 } from "@noble/hashes/utils";
+import { sha256 as sha2564 } from "@noble/hashes/sha256";
 
 // src/privacy.ts
-import { sha256 as sha2564 } from "@noble/hashes/sha256";
-import { sha512 as sha5122 } from "@noble/hashes/sha512";
+import { sha256 as sha2563 } from "@noble/hashes/sha256";
+import { sha512 } from "@noble/hashes/sha512";
 import { hmac } from "@noble/hashes/hmac";
 import { hkdf } from "@noble/hashes/hkdf";
-import { bytesToHex as bytesToHex4, hexToBytes as hexToBytes3, randomBytes as randomBytes5, utf8ToBytes } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex3, hexToBytes as hexToBytes2, randomBytes as randomBytes3, utf8ToBytes } from "@noble/hashes/utils";
 import { xchacha20poly1305 } from "@noble/ciphers/chacha.js";
 var MAX_TRANSACTION_DATA_SIZE = 1024 * 1024;
 function getPrivacyConfig(level, viewingKey) {
@@ -1353,14 +345,14 @@ function getPrivacyConfig(level, viewingKey) {
   }
 }
 function generateViewingKey(path = "m/0") {
-  const keyBytes = randomBytes5(32);
+  const keyBytes = randomBytes3(32);
   try {
-    const key = `0x${bytesToHex4(keyBytes)}`;
-    const hashBytes = sha2564(keyBytes);
+    const key = `0x${bytesToHex3(keyBytes)}`;
+    const hashBytes = sha2563(keyBytes);
     return {
       key,
       path,
-      hash: `0x${bytesToHex4(hashBytes)}`
+      hash: `0x${bytesToHex3(hashBytes)}`
     };
   } finally {
     secureWipe(keyBytes);
@@ -1368,17 +360,17 @@ function generateViewingKey(path = "m/0") {
 }
 function deriveViewingKey(masterKey, childPath) {
   const masterKeyHex = masterKey.key.startsWith("0x") ? masterKey.key.slice(2) : masterKey.key;
-  const masterKeyBytes = hexToBytes3(masterKeyHex);
+  const masterKeyBytes = hexToBytes2(masterKeyHex);
   const childPathBytes = utf8ToBytes(childPath);
-  const derivedFull = hmac(sha5122, masterKeyBytes, childPathBytes);
+  const derivedFull = hmac(sha512, masterKeyBytes, childPathBytes);
   try {
     const derivedBytes = derivedFull.slice(0, 32);
-    const derived = `0x${bytesToHex4(derivedBytes)}`;
-    const hashBytes = sha2564(derivedBytes);
+    const derived = `0x${bytesToHex3(derivedBytes)}`;
+    const hashBytes = sha2563(derivedBytes);
     const result = {
       key: derived,
       path: `${masterKey.path}/${childPath}`,
-      hash: `0x${bytesToHex4(hashBytes)}`
+      hash: `0x${bytesToHex3(hashBytes)}`
     };
     secureWipe(derivedBytes);
     return result;
@@ -1391,11 +383,11 @@ var ENCRYPTION_DOMAIN = "SIP-VIEWING-KEY-ENCRYPTION-V1";
 var NONCE_SIZE = 24;
 function deriveEncryptionKey(viewingKey) {
   const keyHex = viewingKey.key.startsWith("0x") ? viewingKey.key.slice(2) : viewingKey.key;
-  const keyBytes = hexToBytes3(keyHex);
+  const keyBytes = hexToBytes2(keyHex);
   try {
     const salt = utf8ToBytes(ENCRYPTION_DOMAIN);
     const info = utf8ToBytes(viewingKey.path);
-    return hkdf(sha2564, keyBytes, salt, info, 32);
+    return hkdf(sha2563, keyBytes, salt, info, 32);
   } finally {
     secureWipe(keyBytes);
   }
@@ -1403,13 +395,13 @@ function deriveEncryptionKey(viewingKey) {
 function encryptForViewing(data, viewingKey) {
   const key = deriveEncryptionKey(viewingKey);
   try {
-    const nonce = randomBytes5(NONCE_SIZE);
+    const nonce = randomBytes3(NONCE_SIZE);
     const plaintext = utf8ToBytes(JSON.stringify(data));
     const cipher = xchacha20poly1305(key, nonce);
     const ciphertext = cipher.encrypt(plaintext);
     return {
-      ciphertext: `0x${bytesToHex4(ciphertext)}`,
-      nonce: `0x${bytesToHex4(nonce)}`,
+      ciphertext: `0x${bytesToHex3(ciphertext)}`,
+      nonce: `0x${bytesToHex3(nonce)}`,
       viewingKeyHash: viewingKey.hash
     };
   } finally {
@@ -1427,9 +419,9 @@ function decryptWithViewing(encrypted, viewingKey) {
   const key = deriveEncryptionKey(viewingKey);
   try {
     const nonceHex = encrypted.nonce.startsWith("0x") ? encrypted.nonce.slice(2) : encrypted.nonce;
-    const nonce = hexToBytes3(nonceHex);
+    const nonce = hexToBytes2(nonceHex);
     const ciphertextHex = encrypted.ciphertext.startsWith("0x") ? encrypted.ciphertext.slice(2) : encrypted.ciphertext;
-    const ciphertext = hexToBytes3(ciphertextHex);
+    const ciphertext = hexToBytes2(ciphertextHex);
     const cipher = xchacha20poly1305(key, nonce);
     let plaintext;
     try {
@@ -1724,8 +716,8 @@ async function createShieldedIntent(params, options) {
   let viewingKeyHash;
   if (viewingKey) {
     const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-    const keyBytes = hexToBytes4(keyHex);
-    viewingKeyHash = `0x${bytesToHex5(sha2565(keyBytes))}`;
+    const keyBytes = hexToBytes3(keyHex);
+    viewingKeyHash = `0x${bytesToHex4(sha2564(keyBytes))}`;
   }
   const privacyConfig = getPrivacyConfig(
     privacy,
@@ -1771,10 +763,16 @@ async function createShieldedIntent(params, options) {
     }
     const hexToUint8 = (hex) => {
       const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-      return hexToBytes4(cleanHex);
+      return hexToBytes3(cleanHex);
     };
-    const effectiveSenderSecret = senderSecret ?? randomBytes6(32);
-    const rawIntentHashBytes = sha2565(new TextEncoder().encode(intentId));
+    if (allowPlaceholders && typeof process !== "undefined" && process.env?.NODE_ENV === "production") {
+      throw new ValidationError(
+        "allowPlaceholders cannot be used in production environment. Provide valid senderSecret and signatures for production use.",
+        "options.allowPlaceholders"
+      );
+    }
+    const effectiveSenderSecret = senderSecret ?? randomBytes4(32);
+    const rawIntentHashBytes = sha2564(new TextEncoder().encode(intentId));
     const intentHashHex = hash(intentId);
     const BN254_MODULUS = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
     let hashValue = 0n;
@@ -1794,18 +792,18 @@ async function createShieldedIntent(params, options) {
       effectiveOwnershipSig = ownershipSignature;
       effectiveAuthSig = authorizationSignature;
     } else if (allowPlaceholders && !senderSecret) {
-      effectiveOwnershipSig = randomBytes6(64);
-      effectiveAuthSig = randomBytes6(64);
+      effectiveOwnershipSig = randomBytes4(64);
+      effectiveAuthSig = randomBytes4(64);
       console.warn(
         "[createShieldedIntent] WARNING: Using placeholder signatures for proof generation. These proofs are NOT cryptographically valid. Do NOT use in production!"
       );
     } else {
-      const { secp256k1: secp256k19 } = await import("@noble/curves/secp256k1");
-      const publicKey = secp256k19.getPublicKey(effectiveSenderSecret, true);
-      const senderAddressBytes = sha2565(publicKey);
-      const ownershipSig = secp256k19.sign(senderAddressBytes, effectiveSenderSecret);
+      const { secp256k1: secp256k18 } = await import("@noble/curves/secp256k1");
+      const publicKey = secp256k18.getPublicKey(effectiveSenderSecret, true);
+      const senderAddressBytes = sha2564(publicKey);
+      const ownershipSig = secp256k18.sign(senderAddressBytes, effectiveSenderSecret);
       effectiveOwnershipSig = ownershipSig.toCompactRawBytes();
-      const authSig = secp256k19.sign(intentHashBytes, effectiveSenderSecret);
+      const authSig = secp256k18.sign(intentHashBytes, effectiveSenderSecret);
       effectiveAuthSig = authSig.toCompactRawBytes();
     }
     const fundingResult = await proofProvider.generateFundingProof({
@@ -1824,7 +822,7 @@ async function createShieldedIntent(params, options) {
       senderBlinding: hexToUint8(senderCommitment.blindingFactor),
       senderSecret: effectiveSenderSecret,
       authorizationSignature: effectiveAuthSig,
-      nonce: randomBytes6(32),
+      nonce: randomBytes4(32),
       timestamp: now,
       expiry: now + ttl
     });
@@ -1997,8 +995,8 @@ var OneClickClient = class {
       params.set("depositMemo", depositMemo);
     }
     const rawStatus = await this.get(`/v0/status?${params.toString()}`);
-    const settlementTxHash = rawStatus.settlementTxHash ?? rawStatus.destinationChainTxHashes?.[0]?.hash;
-    const depositTxHash = rawStatus.depositTxHash ?? rawStatus.originChainTxHashes?.[0]?.hash;
+    const settlementTxHash = rawStatus.settlementTxHash ?? rawStatus.swapDetails?.destinationChainTxHashes?.[0]?.hash ?? rawStatus.destinationChainTxHashes?.[0]?.hash;
+    const depositTxHash = rawStatus.depositTxHash ?? rawStatus.swapDetails?.originChainTxHashes?.[0]?.hash ?? rawStatus.originChainTxHashes?.[0]?.hash;
     return {
       ...rawStatus,
       settlementTxHash,
@@ -2201,7 +1199,7 @@ import {
 
 // src/move/aptos.ts
 import { sha3_256 } from "@noble/hashes/sha3";
-import { bytesToHex as bytesToHex6, hexToBytes as hexToBytes5 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex5, hexToBytes as hexToBytes4 } from "@noble/hashes/utils";
 var APTOS_SINGLE_ED25519_SCHEME = 0;
 function ed25519PublicKeyToAptosAddress(publicKey) {
   if (!isValidHex(publicKey)) {
@@ -2216,12 +1214,12 @@ function ed25519PublicKeyToAptosAddress(publicKey) {
       "publicKey"
     );
   }
-  const publicKeyBytes = hexToBytes5(publicKey.slice(2));
+  const publicKeyBytes = hexToBytes4(publicKey.slice(2));
   const authKeyInput = new Uint8Array(publicKeyBytes.length + 1);
   authKeyInput.set(publicKeyBytes, 0);
   authKeyInput[publicKeyBytes.length] = APTOS_SINGLE_ED25519_SCHEME;
   const addressHash = sha3_256(authKeyInput);
-  return `0x${bytesToHex6(addressHash)}`;
+  return `0x${bytesToHex5(addressHash)}`;
 }
 function isValidAptosAddress(address) {
   if (typeof address !== "string" || address.length === 0) {
@@ -2335,7 +1333,7 @@ var AptosStealthService = class {
 
 // src/move/sui.ts
 import { BLAKE2b } from "@noble/hashes/blake2b";
-import { bytesToHex as bytesToHex7, hexToBytes as hexToBytes6 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex6, hexToBytes as hexToBytes5 } from "@noble/hashes/utils";
 var SUI_ED25519_SCHEME = 0;
 function ed25519PublicKeyToSuiAddress(publicKey) {
   if (!isValidHex(publicKey)) {
@@ -2350,14 +1348,14 @@ function ed25519PublicKeyToSuiAddress(publicKey) {
       "publicKey"
     );
   }
-  const publicKeyBytes = hexToBytes6(publicKey.slice(2));
+  const publicKeyBytes = hexToBytes5(publicKey.slice(2));
   const addressInput = new Uint8Array(publicKeyBytes.length + 1);
   addressInput[0] = SUI_ED25519_SCHEME;
   addressInput.set(publicKeyBytes, 1);
   const hasher = new BLAKE2b({ dkLen: 32 });
   hasher.update(addressInput);
   const addressHash = hasher.digest();
-  return `0x${bytesToHex7(addressHash)}`;
+  return `0x${bytesToHex6(addressHash)}`;
 }
 function isValidSuiAddress(address) {
   if (typeof address !== "string" || address.length === 0) {
@@ -3330,6 +2328,80 @@ var SIP = class {
       fulfilledAt: Math.floor(Date.now() / 1e3)
     };
   }
+  // ─── Same-Chain Privacy ───────────────────────────────────────────────────
+  /**
+   * Execute a same-chain private transfer
+   *
+   * Bypasses cross-chain settlement for direct on-chain privacy transfers.
+   * Currently supports Solana only.
+   *
+   * @param chain - Chain to execute on (must be 'solana')
+   * @param params - Transfer parameters
+   * @returns Transfer result with stealth address
+   *
+   * @example
+   * ```typescript
+   * const result = await sip.executeSameChain('solana', {
+   *   recipientMetaAddress: {
+   *     chain: 'solana',
+   *     spendingKey: '0x...',
+   *     viewingKey: '0x...',
+   *   },
+   *   amount: 5_000_000n,  // 5 USDC
+   *   token: 'USDC',
+   *   connection,
+   *   sender: wallet.publicKey,
+   *   signTransaction: wallet.signTransaction,
+   * })
+   *
+   * console.log('Sent to stealth:', result.stealthAddress)
+   * ```
+   */
+  async executeSameChain(chain, params) {
+    if (chain !== "solana") {
+      throw new ValidationError(
+        `Same-chain privacy only supported for 'solana', got '${chain}'`,
+        "chain"
+      );
+    }
+    const { sendPrivateSPLTransfer: sendPrivateSPLTransfer2 } = await import("./solana-5EMCTPTS.mjs");
+    const { PublicKey: SolanaPublicKey } = await import("@solana/web3.js");
+    const { getAssociatedTokenAddress } = await import("@solana/spl-token");
+    const { SOLANA_TOKEN_MINTS: SOLANA_TOKEN_MINTS2 } = await import("./constants-VOI7BSLK.mjs");
+    let mint;
+    if (params.token in SOLANA_TOKEN_MINTS2) {
+      mint = new SolanaPublicKey(SOLANA_TOKEN_MINTS2[params.token]);
+    } else {
+      mint = new SolanaPublicKey(params.token);
+    }
+    const senderTokenAccount = await getAssociatedTokenAddress(
+      mint,
+      params.sender
+    );
+    const result = await sendPrivateSPLTransfer2({
+      connection: params.connection,
+      sender: params.sender,
+      senderTokenAccount,
+      recipientMetaAddress: params.recipientMetaAddress,
+      mint,
+      amount: params.amount,
+      signTransaction: params.signTransaction
+    });
+    return {
+      txHash: result.txSignature,
+      stealthAddress: result.stealthAddress,
+      ephemeralPublicKey: result.ephemeralPublicKey,
+      viewTag: result.viewTag,
+      explorerUrl: result.explorerUrl,
+      chain: "solana"
+    };
+  }
+  /**
+   * Check if same-chain privacy is supported for a chain
+   */
+  isSameChainSupported(chain) {
+    return chain === "solana";
+  }
 };
 function createSIP(network = "testnet") {
   return new SIP({ network });
@@ -3346,9 +2418,9 @@ function createProductionSIP(config) {
 }
 
 // src/cosmos/stealth.ts
-import { sha256 as sha2566 } from "@noble/hashes/sha256";
+import { sha256 as sha2565 } from "@noble/hashes/sha256";
 import { ripemd160 } from "@noble/hashes/ripemd160";
-import { hexToBytes as hexToBytes7, bytesToHex as bytesToHex8 } from "@noble/hashes/utils";
+import { hexToBytes as hexToBytes6, bytesToHex as bytesToHex7 } from "@noble/hashes/utils";
 import { bech32 } from "@scure/base";
 var CHAIN_PREFIXES = {
   cosmos: "cosmos",
@@ -3430,14 +2502,14 @@ var CosmosStealthService = class {
       );
     }
     const metaAddress = {
-      spendingKey: `0x${bytesToHex8(spendingPubKey)}`,
-      viewingKey: `0x${bytesToHex8(viewingPubKey)}`,
+      spendingKey: `0x${bytesToHex7(spendingPubKey)}`,
+      viewingKey: `0x${bytesToHex7(viewingPubKey)}`,
       chain: "ethereum"
       // Use ethereum for secp256k1 generation
     };
     const { stealthAddress, sharedSecret } = generateStealthAddress(metaAddress);
     const cosmosAddress = this.stealthKeyToCosmosAddress(
-      hexToBytes7(stealthAddress.address.slice(2)),
+      hexToBytes6(stealthAddress.address.slice(2)),
       CHAIN_PREFIXES[chain]
     );
     return {
@@ -3465,8 +2537,8 @@ var CosmosStealthService = class {
    * ```
    */
   generateStealthAddressFromMeta(recipientMetaAddress, chain) {
-    const spendingPubKey = hexToBytes7(recipientMetaAddress.spendingKey.slice(2));
-    const viewingPubKey = hexToBytes7(recipientMetaAddress.viewingKey.slice(2));
+    const spendingPubKey = hexToBytes6(recipientMetaAddress.spendingKey.slice(2));
+    const viewingPubKey = hexToBytes6(recipientMetaAddress.viewingKey.slice(2));
     return this.generateStealthAddress(spendingPubKey, viewingPubKey, chain);
   }
   /**
@@ -3496,7 +2568,7 @@ var CosmosStealthService = class {
         "publicKey"
       );
     }
-    const sha256Hash = sha2566(publicKey);
+    const sha256Hash = sha2565(publicKey);
     const hash160 = ripemd160(sha256Hash);
     const words = bech32.toWords(hash160);
     return bech32.encode(prefix, words);
@@ -3644,13 +2716,13 @@ function isValidCosmosAddress(address, expectedChain) {
 }
 
 // src/cosmos/ibc-stealth.ts
-import { hexToBytes as hexToBytes8, bytesToHex as bytesToHex9 } from "@noble/hashes/utils";
-import { secp256k1 as secp256k13 } from "@noble/curves/secp256k1";
-import { sha256 as sha2567 } from "@noble/hashes/sha256";
+import { hexToBytes as hexToBytes7, bytesToHex as bytesToHex8 } from "@noble/hashes/utils";
+import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1";
+import { sha256 as sha2566 } from "@noble/hashes/sha256";
 
 // src/proofs/mock.ts
-import { sha256 as sha2568 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex10, randomBytes as randomBytes7 } from "@noble/hashes/utils";
+import { sha256 as sha2567 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex9, randomBytes as randomBytes5 } from "@noble/hashes/utils";
 var MOCK_PROOF_PREFIX = "0x4d4f434b";
 var WARNING_MESSAGE = `
 \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
@@ -3815,17 +2887,17 @@ var MockProofProvider = class {
       { type: proofType, params },
       (_, v) => typeof v === "bigint" ? v.toString() : v
     );
-    const hash2 = sha2568(new TextEncoder().encode(input));
-    const random = randomBytes7(16);
+    const hash2 = sha2567(new TextEncoder().encode(input));
+    const random = randomBytes5(16);
     const combined = new Uint8Array(4 + hash2.length + random.length);
     combined.set(new TextEncoder().encode("MOCK"), 0);
     combined.set(hash2, 4);
     combined.set(random, 4 + hash2.length);
-    return `${MOCK_PROOF_PREFIX}${bytesToHex10(combined.slice(4))}`;
+    return `${MOCK_PROOF_PREFIX}${bytesToHex9(combined.slice(4))}`;
   }
   hashToHex(data) {
-    const hash2 = sha2568(new TextEncoder().encode(data));
-    return `0x${bytesToHex10(hash2)}`;
+    const hash2 = sha2567(new TextEncoder().encode(data));
+    return `0x${bytesToHex9(hash2)}`;
   }
 };
 
@@ -4098,7 +3170,7 @@ function checkMobileWASMCompatibility() {
     recommendations
   };
 }
-function hexToBytes9(hex) {
+function hexToBytes8(hex) {
   const h = hex.startsWith("0x") ? hex.slice(2) : hex;
   if (h.length === 0) return new Uint8Array(0);
   if (h.length % 2 !== 0) {
@@ -4110,7 +3182,7 @@ function hexToBytes9(hex) {
   }
   return bytes;
 }
-function bytesToHex11(bytes) {
+function bytesToHex10(bytes) {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 function isBrowser() {
@@ -4173,13 +3245,13 @@ var CHAIN_NUMERIC_IDS = {
 };
 
 // src/oracle/verification.ts
-import { ed25519 as ed255192 } from "@noble/curves/ed25519";
-import { sha256 as sha25610 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex13, hexToBytes as hexToBytes11 } from "@noble/hashes/utils";
+import { ed25519 } from "@noble/curves/ed25519";
+import { sha256 as sha2569 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex12, hexToBytes as hexToBytes10 } from "@noble/hashes/utils";
 
 // src/oracle/serialization.ts
-import { sha256 as sha2569 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex12, hexToBytes as hexToBytes10, utf8ToBytes as utf8ToBytes2 } from "@noble/hashes/utils";
+import { sha256 as sha2568 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex11, hexToBytes as hexToBytes9, utf8ToBytes as utf8ToBytes2 } from "@noble/hashes/utils";
 function serializeAttestationMessage(message) {
   const buffer = new Uint8Array(197);
   const view = new DataView(buffer.buffer);
@@ -4222,19 +3294,19 @@ function deserializeAttestationMessage(bytes) {
   const version = bytes[offset++];
   const chainId = view.getUint32(offset, false);
   offset += 4;
-  const intentHash = `0x${bytesToHex12(bytes.slice(offset, offset + 32))}`;
+  const intentHash = `0x${bytesToHex11(bytes.slice(offset, offset + 32))}`;
   offset += 32;
-  const recipient = `0x${bytesToHex12(bytes.slice(offset, offset + 32))}`;
+  const recipient = `0x${bytesToHex11(bytes.slice(offset, offset + 32))}`;
   offset += 32;
   const amount = bytesToBigint(bytes.slice(offset, offset + 16));
   offset += 16;
-  const assetId = `0x${bytesToHex12(bytes.slice(offset, offset + 32))}`;
+  const assetId = `0x${bytesToHex11(bytes.slice(offset, offset + 32))}`;
   offset += 32;
-  const txHash = `0x${bytesToHex12(bytes.slice(offset, offset + 32))}`;
+  const txHash = `0x${bytesToHex11(bytes.slice(offset, offset + 32))}`;
   offset += 32;
   const blockNumber = view.getBigUint64(offset, false);
   offset += 8;
-  const blockHash = `0x${bytesToHex12(bytes.slice(offset, offset + 32))}`;
+  const blockHash = `0x${bytesToHex11(bytes.slice(offset, offset + 32))}`;
   offset += 32;
   const timestamp = Number(view.getBigUint64(offset, false));
   return {
@@ -4256,7 +3328,7 @@ function computeAttestationHash(message) {
   const toHash = new Uint8Array(domain.length + messageBytes.length);
   toHash.set(domain, 0);
   toHash.set(messageBytes, domain.length);
-  return sha2569(toHash);
+  return sha2568(toHash);
 }
 function getChainNumericId(chain) {
   const id = CHAIN_NUMERIC_IDS[chain];
@@ -4267,7 +3339,7 @@ function getChainNumericId(chain) {
 }
 function normalizeToBytes(hex, length, field) {
   const stripped = hex.startsWith("0x") ? hex.slice(2) : hex;
-  const bytes = hexToBytes10(stripped);
+  const bytes = hexToBytes9(stripped);
   if (bytes.length === length) {
     return bytes;
   }
@@ -4300,9 +3372,9 @@ function bytesToBigint(bytes) {
 
 // src/oracle/verification.ts
 function deriveOracleId(publicKey) {
-  const keyBytes = typeof publicKey === "string" ? hexToBytes11(publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey) : publicKey;
-  const hash2 = sha25610(keyBytes);
-  return `0x${bytesToHex13(hash2)}`;
+  const keyBytes = typeof publicKey === "string" ? hexToBytes10(publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey) : publicKey;
+  const hash2 = sha2569(keyBytes);
+  return `0x${bytesToHex12(hash2)}`;
 }
 function verifyAttestation(attestation, registry) {
   const { message, signatures } = attestation;
@@ -4332,13 +3404,13 @@ function verifyAttestation(attestation, registry) {
       continue;
     }
     try {
-      const publicKeyBytes = hexToBytes11(
+      const publicKeyBytes = hexToBytes10(
         oracle.publicKey.startsWith("0x") ? oracle.publicKey.slice(2) : oracle.publicKey
       );
-      const signatureBytes = hexToBytes11(
+      const signatureBytes = hexToBytes10(
         sig.signature.startsWith("0x") ? sig.signature.slice(2) : sig.signature
       );
-      const isValid = ed255192.verify(signatureBytes, messageHash, publicKeyBytes);
+      const isValid = ed25519.verify(signatureBytes, messageHash, publicKeyBytes);
       if (isValid) {
         validCount++;
         validOracles.push(sig.oracleId);
@@ -4360,24 +3432,24 @@ function verifyAttestation(attestation, registry) {
 }
 function verifyOracleSignature(signature, messageHash, oracle) {
   try {
-    const publicKeyBytes = hexToBytes11(
+    const publicKeyBytes = hexToBytes10(
       oracle.publicKey.startsWith("0x") ? oracle.publicKey.slice(2) : oracle.publicKey
     );
-    const signatureBytes = hexToBytes11(
+    const signatureBytes = hexToBytes10(
       signature.signature.startsWith("0x") ? signature.signature.slice(2) : signature.signature
     );
-    return ed255192.verify(signatureBytes, messageHash, publicKeyBytes);
+    return ed25519.verify(signatureBytes, messageHash, publicKeyBytes);
   } catch {
     return false;
   }
 }
 function signAttestationMessage(messageHash, privateKey) {
-  const signature = ed255192.sign(messageHash, privateKey);
-  const publicKey = ed255192.getPublicKey(privateKey);
+  const signature = ed25519.sign(messageHash, privateKey);
+  const publicKey = ed25519.getPublicKey(privateKey);
   const oracleId = deriveOracleId(publicKey);
   return {
     oracleId,
-    signature: `0x${bytesToHex13(signature)}`
+    signature: `0x${bytesToHex12(signature)}`
   };
 }
 function createOracleRegistry(config = {}) {
@@ -4445,7 +3517,7 @@ import { ReportStatus as ReportStatus2 } from "@sip-protocol/types";
 import {
   IntentStatus as IntentStatus3
 } from "@sip-protocol/types";
-import { bytesToHex as bytesToHex14, randomBytes as randomBytes8 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex13, randomBytes as randomBytes6 } from "@noble/hashes/utils";
 var MockSolver = class {
   info;
   capabilities;
@@ -4527,7 +3599,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-${bytesToHex14(randomBytes8(8))}`;
+    const quoteId = `quote-${bytesToHex13(randomBytes6(8))}`;
     const now = Math.floor(Date.now() / 1e3);
     const quote = {
       quoteId,
@@ -4538,7 +3610,7 @@ var MockSolver = class {
       expiry: now + 60,
       // Quote valid for 1 minute
       fee: feeAmount,
-      signature: `0x${bytesToHex14(randomBytes8(64))}`,
+      signature: `0x${bytesToHex13(randomBytes6(64))}`,
       // Mock signature
       validUntil: now + 60,
       estimatedGas: 200000n
@@ -4575,7 +3647,7 @@ var MockSolver = class {
         error: status.error
       };
     }
-    const txHash = `0x${bytesToHex14(randomBytes8(32))}`;
+    const txHash = `0x${bytesToHex13(randomBytes6(32))}`;
     status.status = "completed";
     status.txHash = txHash;
     return {
@@ -4585,10 +3657,10 @@ var MockSolver = class {
       txHash: intent.privacyLevel === "transparent" ? txHash : void 0,
       fulfillmentProof: {
         type: "fulfillment",
-        proof: `0x${bytesToHex14(randomBytes8(128))}`,
+        proof: `0x${bytesToHex13(randomBytes6(128))}`,
         publicInputs: [
-          `0x${bytesToHex14(new TextEncoder().encode(intent.intentId))}`,
-          `0x${bytesToHex14(new TextEncoder().encode(quote.quoteId))}`
+          `0x${bytesToHex13(new TextEncoder().encode(intent.intentId))}`,
+          `0x${bytesToHex13(new TextEncoder().encode(quote.quoteId))}`
         ]
       },
       fulfilledAt: Math.floor(Date.now() / 1e3)
@@ -5740,7 +4812,7 @@ function createZcashNativeBackend(config) {
 
 // src/settlement/backends/direct-chain.ts
 import { PrivacyLevel as PrivacyLevel5 } from "@sip-protocol/types";
-import { randomBytes as randomBytes9, bytesToHex as bytesToHex15 } from "@noble/hashes/utils";
+import { randomBytes as randomBytes7, bytesToHex as bytesToHex14 } from "@noble/hashes/utils";
 var DEFAULT_GAS_FEES = {
   ethereum: 21000n * 50n * 1000000000n,
   // 21k gas * 50 gwei = 0.00105 ETH
@@ -7067,18 +6139,18 @@ import { ZcashErrorCode as ZcashErrorCode2 } from "@sip-protocol/types";
 import { ZcashErrorCode as ZcashErrorCode3 } from "@sip-protocol/types";
 
 // src/bitcoin/taproot.ts
-import { secp256k1 as secp256k14, schnorr } from "@noble/curves/secp256k1";
-import { sha256 as sha25611 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex16, hexToBytes as hexToBytes12 } from "@noble/hashes/utils";
+import { secp256k1 as secp256k13, schnorr } from "@noble/curves/secp256k1";
+import { sha256 as sha25610 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex15, hexToBytes as hexToBytes11 } from "@noble/hashes/utils";
 var BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
 var BECH32_GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
 function taggedHash(tag, data) {
-  const tagHash = sha25611(new TextEncoder().encode(tag));
+  const tagHash = sha25610(new TextEncoder().encode(tag));
   const taggedData = new Uint8Array(tagHash.length * 2 + data.length);
   taggedData.set(tagHash, 0);
   taggedData.set(tagHash, tagHash.length);
   taggedData.set(data, tagHash.length * 2);
-  return sha25611(taggedData);
+  return sha25610(taggedData);
 }
 function schnorrSign(message, privateKey, auxRand) {
   if (message.length !== 32) {
@@ -7112,7 +6184,7 @@ function getXOnlyPublicKey(privateKey) {
   if (privateKey.length !== 32) {
     throw new ValidationError("privateKey must be 32 bytes", "privateKey");
   }
-  const publicKey = secp256k14.getPublicKey(privateKey, false);
+  const publicKey = secp256k13.getPublicKey(privateKey, false);
   return publicKey.slice(1, 33);
 }
 function computeTweakedKey(internalKey, merkleRoot) {
@@ -7124,16 +6196,16 @@ function computeTweakedKey(internalKey, merkleRoot) {
   }
   const tweakData = merkleRoot ? new Uint8Array([...internalKey, ...merkleRoot]) : internalKey;
   const tweak = taggedHash("TapTweak", tweakData);
-  const tweakScalar = BigInt("0x" + bytesToHex16(tweak)) % secp256k14.CURVE.n;
-  const internalPoint = secp256k14.ProjectivePoint.fromHex(
-    "02" + bytesToHex16(internalKey)
+  const tweakScalar = BigInt("0x" + bytesToHex15(tweak)) % secp256k13.CURVE.n;
+  const internalPoint = secp256k13.ProjectivePoint.fromHex(
+    "02" + bytesToHex15(internalKey)
   );
-  const tweakPoint = secp256k14.ProjectivePoint.BASE.multiply(tweakScalar);
+  const tweakPoint = secp256k13.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" + bytesToHex16(yCoord));
+  const yBigInt = BigInt("0x" + bytesToHex15(yCoord));
   const parity = Number(yBigInt & 1n);
   return {
     tweakedKey: xOnly,
@@ -7163,9 +6235,9 @@ function createTaprootOutput(internalKey, scripts) {
   }
   const { tweakedKey, parity } = computeTweakedKey(internalKey, merkleRoot);
   return {
-    tweakedKey: `0x${bytesToHex16(tweakedKey)}`,
-    internalKey: `0x${bytesToHex16(internalKey)}`,
-    merkleRoot: merkleRoot ? `0x${bytesToHex16(merkleRoot)}` : void 0,
+    tweakedKey: `0x${bytesToHex15(tweakedKey)}`,
+    internalKey: `0x${bytesToHex15(internalKey)}`,
+    merkleRoot: merkleRoot ? `0x${bytesToHex15(merkleRoot)}` : void 0,
     parity
   };
 }
@@ -7298,10 +6370,10 @@ function createKeySpendOnlyOutput(privateKey, network = "mainnet") {
   if (!isValidPrivateKey(privateKey)) {
     throw new ValidationError("privateKey must be a valid 32-byte hex string", "privateKey");
   }
-  const privKeyBytes = hexToBytes12(privateKey.slice(2));
+  const privKeyBytes = hexToBytes11(privateKey.slice(2));
   const internalKey = getXOnlyPublicKey(privKeyBytes);
   const output = createTaprootOutput(internalKey);
-  const tweakedKeyBytes = hexToBytes12(output.tweakedKey.slice(2));
+  const tweakedKeyBytes = hexToBytes11(output.tweakedKey.slice(2));
   const address = taprootAddress(tweakedKeyBytes, network);
   return {
     output,
@@ -7327,11 +6399,11 @@ function schnorrSignHex(message, privateKey, auxRand) {
   if (auxRand && !isValidHex(auxRand)) {
     throw new ValidationError("auxRand must be a hex string", "auxRand");
   }
-  const messageBytes = hexToBytes12(message.slice(2));
-  const privateKeyBytes = hexToBytes12(privateKey.slice(2));
-  const auxRandBytes = auxRand ? hexToBytes12(auxRand.slice(2)) : void 0;
+  const messageBytes = hexToBytes11(message.slice(2));
+  const privateKeyBytes = hexToBytes11(privateKey.slice(2));
+  const auxRandBytes = auxRand ? hexToBytes11(auxRand.slice(2)) : void 0;
   const signature = schnorrSign(messageBytes, privateKeyBytes, auxRandBytes);
-  return `0x${bytesToHex16(signature)}`;
+  return `0x${bytesToHex15(signature)}`;
 }
 function schnorrVerifyHex(signature, message, publicKey) {
   if (!isValidHex(signature)) {
@@ -7343,16 +6415,16 @@ function schnorrVerifyHex(signature, message, publicKey) {
   if (!isValidHex(publicKey)) {
     throw new ValidationError("publicKey must be a hex string", "publicKey");
   }
-  const signatureBytes = hexToBytes12(signature.slice(2));
-  const messageBytes = hexToBytes12(message.slice(2));
-  const publicKeyBytes = hexToBytes12(publicKey.slice(2));
+  const signatureBytes = hexToBytes11(signature.slice(2));
+  const messageBytes = hexToBytes11(message.slice(2));
+  const publicKeyBytes = hexToBytes11(publicKey.slice(2));
   return schnorrVerify(signatureBytes, messageBytes, publicKeyBytes);
 }
 
 // src/bitcoin/silent-payments.ts
-import { secp256k1 as secp256k15 } from "@noble/curves/secp256k1";
-import { sha256 as sha25612 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex17, hexToBytes as hexToBytes13 } from "@noble/hashes/utils";
+import { secp256k1 as secp256k14 } from "@noble/curves/secp256k1";
+import { sha256 as sha25611 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex16, hexToBytes as hexToBytes12 } from "@noble/hashes/utils";
 
 // src/payment/payment.ts
 import {
@@ -7360,8 +6432,8 @@ import {
   PrivacyLevel as PrivacyLevel8,
   PaymentStatus
 } from "@sip-protocol/types";
-import { sha256 as sha25613 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex18, hexToBytes as hexToBytes14, randomBytes as randomBytes10 } from "@noble/hashes/utils";
+import { sha256 as sha25612 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex17, hexToBytes as hexToBytes13, randomBytes as randomBytes8 } from "@noble/hashes/utils";
 import { xchacha20poly1305 as xchacha20poly13052 } from "@noble/ciphers/chacha.js";
 import { hkdf as hkdf2 } from "@noble/hashes/hkdf";
 
@@ -7857,8 +6929,8 @@ async function createShieldedPayment(params, options) {
   let viewingKeyHash;
   if (viewingKey) {
     const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-    const keyBytes = hexToBytes14(keyHex);
-    viewingKeyHash = `0x${bytesToHex18(sha25613(keyBytes))}`;
+    const keyBytes = hexToBytes13(keyHex);
+    viewingKeyHash = `0x${bytesToHex17(sha25612(keyBytes))}`;
   }
   const privacyConfig = getPrivacyConfig(
     privacy,
@@ -7898,7 +6970,7 @@ async function createShieldedPayment(params, options) {
   if (privacy !== PrivacyLevel8.TRANSPARENT && proofProvider?.isReady) {
     const hexToUint8 = (hex) => {
       const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-      return hexToBytes14(cleanHex);
+      return hexToBytes13(cleanHex);
     };
     const fundingResult = await proofProvider.generateFundingProof({
       balance: amount,
@@ -7925,17 +6997,17 @@ async function createShieldedPayment(params, options) {
 }
 function encryptMemo(memo, viewingKey) {
   const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-  const keyBytes = hexToBytes14(keyHex);
-  const encKey = hkdf2(sha25613, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
+  const keyBytes = hexToBytes13(keyHex);
+  const encKey = hkdf2(sha25612, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
   try {
-    const nonce = randomBytes10(24);
+    const nonce = randomBytes8(24);
     const cipher = xchacha20poly13052(encKey, nonce);
     const plaintext = new TextEncoder().encode(memo);
     const ciphertext = cipher.encrypt(plaintext);
     const result = new Uint8Array(nonce.length + ciphertext.length);
     result.set(nonce);
     result.set(ciphertext, nonce.length);
-    return `0x${bytesToHex18(result)}`;
+    return `0x${bytesToHex17(result)}`;
   } finally {
     secureWipe(keyBytes);
     secureWipe(encKey);
@@ -7943,11 +7015,11 @@ function encryptMemo(memo, viewingKey) {
 }
 function decryptMemo(encryptedMemo, viewingKey) {
   const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-  const keyBytes = hexToBytes14(keyHex);
-  const encKey = hkdf2(sha25613, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
+  const keyBytes = hexToBytes13(keyHex);
+  const encKey = hkdf2(sha25612, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
   try {
     const dataHex = encryptedMemo.startsWith("0x") ? encryptedMemo.slice(2) : encryptedMemo;
-    const data = hexToBytes14(dataHex);
+    const data = hexToBytes13(dataHex);
     const nonce = data.slice(0, 24);
     const ciphertext = data.slice(24);
     const cipher = xchacha20poly13052(encKey, nonce);
@@ -7998,9 +7070,9 @@ import {
   ProposalStatus,
   PrivacyLevel as PrivacyLevel9
 } from "@sip-protocol/types";
-import { secp256k1 as secp256k16 } from "@noble/curves/secp256k1";
-import { sha256 as sha25614 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex19, hexToBytes as hexToBytes15, randomBytes as randomBytes11 } from "@noble/hashes/utils";
+import { secp256k1 as secp256k15 } from "@noble/curves/secp256k1";
+import { sha256 as sha25613 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex18, hexToBytes as hexToBytes14, randomBytes as randomBytes9 } from "@noble/hashes/utils";
 var DEFAULT_PROPOSAL_TTL = 7 * 24 * 60 * 60;
 var Treasury = class _Treasury {
   config;
@@ -8491,12 +7563,12 @@ var Treasury = class _Treasury {
   }
 };
 function generateTreasuryId() {
-  const bytes = randomBytes11(16);
-  return `treasury_${bytesToHex19(bytes)}`;
+  const bytes = randomBytes9(16);
+  return `treasury_${bytesToHex18(bytes)}`;
 }
 function generateProposalId() {
-  const bytes = randomBytes11(16);
-  return `prop_${bytesToHex19(bytes)}`;
+  const bytes = randomBytes9(16);
+  return `prop_${bytesToHex18(bytes)}`;
 }
 function computeProposalHash(proposal) {
   const data = JSON.stringify({
@@ -8508,13 +7580,13 @@ function computeProposalHash(proposal) {
     createdAt: proposal.createdAt,
     expiresAt: proposal.expiresAt
   }, (_, value) => typeof value === "bigint" ? value.toString() : value);
-  return sha25614(new TextEncoder().encode(data));
+  return sha25613(new TextEncoder().encode(data));
 }
 function signMessage(messageHash, privateKey) {
   const keyHex = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
-  const keyBytes = hexToBytes15(keyHex);
+  const keyBytes = hexToBytes14(keyHex);
   try {
-    const signature = secp256k16.sign(messageHash, keyBytes);
+    const signature = secp256k15.sign(messageHash, keyBytes);
     return `0x${signature.toCompactHex()}`;
   } finally {
     secureWipe(keyBytes);
@@ -8524,9 +7596,9 @@ function verifySignature(messageHash, signature, publicKey) {
   const sigHex = signature.startsWith("0x") ? signature.slice(2) : signature;
   const pubKeyHex = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
   try {
-    const sigBytes = hexToBytes15(sigHex);
-    const pubKeyBytes = hexToBytes15(pubKeyHex);
-    return secp256k16.verify(sigBytes, messageHash, pubKeyBytes);
+    const sigBytes = hexToBytes14(sigHex);
+    const pubKeyBytes = hexToBytes14(pubKeyHex);
+    return secp256k15.verify(sigBytes, messageHash, pubKeyBytes);
   } catch {
     return false;
   }
@@ -8686,7 +7758,7 @@ function validateBatchProposalParams(params, config) {
 import {
   ReportStatus
 } from "@sip-protocol/types";
-import { bytesToHex as bytesToHex20, randomBytes as randomBytes12 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex19, randomBytes as randomBytes10 } from "@noble/hashes/utils";
 var DEFAULTS2 = {
   riskThreshold: 70,
   highValueThreshold: 10000000000n,
@@ -9433,7 +8505,7 @@ var ComplianceManager = class _ComplianceManager {
   }
 };
 function generateId(prefix) {
-  return `${prefix}_${bytesToHex20(randomBytes12(12))}`;
+  return `${prefix}_${bytesToHex19(randomBytes10(12))}`;
 }
 function validateRegisterAuditorParams(params) {
   if (!params.organization?.trim()) {
@@ -9521,8 +8593,8 @@ function validateReportParams(params) {
 }
 
 // src/compliance/reports.ts
-import { sha256 as sha25615 } from "@noble/hashes/sha256";
-import { hexToBytes as hexToBytes16, bytesToHex as bytesToHex21 } from "@noble/hashes/utils";
+import { sha256 as sha25614 } from "@noble/hashes/sha256";
+import { hexToBytes as hexToBytes15, bytesToHex as bytesToHex20 } from "@noble/hashes/utils";
 
 // src/compliance/pdf.ts
 function generatePdfReport(report, options = {}) {
@@ -9823,12 +8895,12 @@ var ComplianceReporter = class {
   normalizeViewingKey(viewingKey) {
     if (typeof viewingKey === "string") {
       const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-      const keyBytes = hexToBytes16(keyHex);
-      const hashBytes = sha25615(keyBytes);
+      const keyBytes = hexToBytes15(keyHex);
+      const hashBytes = sha25614(keyBytes);
       return {
         key: `0x${keyHex}`,
         path: "m/0",
-        hash: `0x${bytesToHex21(hashBytes)}`
+        hash: `0x${bytesToHex20(hashBytes)}`
       };
     }
     return viewingKey;
@@ -10209,8 +9281,8 @@ var ComplianceReporter = class {
 };
 
 // src/compliance/conditional.ts
-import { sha256 as sha25616 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex22, hexToBytes as hexToBytes17, randomBytes as randomBytes13 } from "@noble/hashes/utils";
+import { sha256 as sha25615 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex21, hexToBytes as hexToBytes16, randomBytes as randomBytes11 } from "@noble/hashes/utils";
 import { xchacha20poly1305 as xchacha20poly13053 } from "@noble/ciphers/chacha.js";
 var ConditionalDisclosure = class {
   /**
@@ -10276,20 +9348,20 @@ var ConditionalDisclosure = class {
         params.commitment,
         revealAfterSeconds
       );
-      const nonce = randomBytes13(24);
-      const viewingKeyBytes = hexToBytes17(params.viewingKey.slice(2));
+      const nonce = randomBytes11(24);
+      const viewingKeyBytes = hexToBytes16(params.viewingKey.slice(2));
       const cipher = xchacha20poly13053(encryptionKey, nonce);
       const encryptedKey = cipher.encrypt(viewingKeyBytes);
       const commitmentData = new Uint8Array([
         ...viewingKeyBytes,
         ...this._numberToBytes(revealAfterSeconds)
       ]);
-      const commitmentHash = sha25616(commitmentData);
+      const commitmentHash = sha25615(commitmentData);
       return {
-        encryptedKey: "0x" + bytesToHex22(encryptedKey),
-        nonce: "0x" + bytesToHex22(nonce),
+        encryptedKey: "0x" + bytesToHex21(encryptedKey),
+        nonce: "0x" + bytesToHex21(nonce),
         revealAfter: revealAfterSeconds,
-        verificationCommitment: "0x" + bytesToHex22(commitmentHash),
+        verificationCommitment: "0x" + bytesToHex21(commitmentHash),
         encryptionCommitment: params.commitment,
         type
       };
@@ -10366,11 +9438,11 @@ var ConditionalDisclosure = class {
         timeLock.encryptionCommitment,
         timeLock.revealAfter
       );
-      const nonce = hexToBytes17(timeLock.nonce.slice(2));
-      const encryptedData = hexToBytes17(timeLock.encryptedKey.slice(2));
+      const nonce = hexToBytes16(timeLock.nonce.slice(2));
+      const encryptedData = hexToBytes16(timeLock.encryptedKey.slice(2));
       const cipher = xchacha20poly13053(encryptionKey, nonce);
       const decryptedBytes = cipher.decrypt(encryptedData);
-      const viewingKey = "0x" + bytesToHex22(decryptedBytes);
+      const viewingKey = "0x" + bytesToHex21(decryptedBytes);
       return {
         unlocked: true,
         viewingKey
@@ -10401,13 +9473,13 @@ var ConditionalDisclosure = class {
    */
   verifyCommitment(timeLock, viewingKey) {
     try {
-      const viewingKeyBytes = hexToBytes17(viewingKey.slice(2));
+      const viewingKeyBytes = hexToBytes16(viewingKey.slice(2));
       const commitmentData = new Uint8Array([
         ...viewingKeyBytes,
         ...this._numberToBytes(timeLock.revealAfter)
       ]);
-      const expectedCommitment = sha25616(commitmentData);
-      const actualCommitment = hexToBytes17(timeLock.verificationCommitment.slice(2));
+      const expectedCommitment = sha25615(commitmentData);
+      const actualCommitment = hexToBytes16(timeLock.verificationCommitment.slice(2));
       if (expectedCommitment.length !== actualCommitment.length) {
         return false;
       }
@@ -10426,10 +9498,10 @@ var ConditionalDisclosure = class {
    * @private
    */
   _deriveEncryptionKey(commitment, revealAfter) {
-    const commitmentBytes = hexToBytes17(commitment.slice(2));
+    const commitmentBytes = hexToBytes16(commitment.slice(2));
     const timeBytes = this._numberToBytes(revealAfter);
     const combined = new Uint8Array([...commitmentBytes, ...timeBytes]);
-    const key = sha25616(combined);
+    const key = sha25615(combined);
     if (key.length !== 32) {
       throw new CryptoError(
         "Derived key must be 32 bytes",
@@ -10456,14 +9528,14 @@ var ConditionalDisclosure = class {
 };
 
 // src/compliance/conditional-threshold.ts
-import { secp256k1 as secp256k17 } from "@noble/curves/secp256k1";
-import { sha256 as sha25617 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex23, hexToBytes as hexToBytes18 } from "@noble/hashes/utils";
-var CURVE_ORDER2 = secp256k17.CURVE.n;
+import { secp256k1 as secp256k16 } from "@noble/curves/secp256k1";
+import { sha256 as sha25616 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex22, hexToBytes as hexToBytes17 } from "@noble/hashes/utils";
+var CURVE_ORDER2 = secp256k16.CURVE.n;
 
 // src/compliance/threshold.ts
-import { sha256 as sha25618 } from "@noble/hashes/sha256";
-import { bytesToHex as bytesToHex24, hexToBytes as hexToBytes19, randomBytes as randomBytes14 } from "@noble/hashes/utils";
+import { sha256 as sha25617 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex23, hexToBytes as hexToBytes18, randomBytes as randomBytes12 } from "@noble/hashes/utils";
 var FIELD_PRIME = 2n ** 256n - 189n;
 var ThresholdViewingKey = class {
   /**
@@ -10646,7 +9718,7 @@ var ThresholdViewingKey = class {
    * Convert viewing key to secret (bigint)
    */
   static viewingKeyToSecret(viewingKey) {
-    const bytes = hexToBytes19(viewingKey.slice(2));
+    const bytes = hexToBytes18(viewingKey.slice(2));
     let secret = 0n;
     for (let i = 0; i < bytes.length; i++) {
       secret = secret << 8n | BigInt(bytes[i]);
@@ -10680,7 +9752,7 @@ var ThresholdViewingKey = class {
    * Generate a random field element
    */
   static randomFieldElement() {
-    const bytes = randomBytes14(32);
+    const bytes = randomBytes12(32);
     let value = 0n;
     for (let i = 0; i < bytes.length; i++) {
       value = value << 8n | BigInt(bytes[i]);
@@ -10705,8 +9777,8 @@ var ThresholdViewingKey = class {
    */
   static createCommitment(secret, coefficients) {
     const data = [secret, ...coefficients].map((c) => c.toString(16).padStart(64, "0")).join("");
-    const hash2 = sha25618(hexToBytes19(data));
-    return bytesToHex24(hash2);
+    const hash2 = sha25617(hexToBytes18(data));
+    return bytesToHex23(hash2);
   }
   /**
    * Encode share as string: "x:y:len:commitment"
@@ -10829,10 +9901,10 @@ var ThresholdViewingKey = class {
 };
 
 // src/compliance/derivation.ts
-import { sha256 as sha25619 } from "@noble/hashes/sha256";
-import { sha512 as sha5123 } from "@noble/hashes/sha512";
+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 bytesToHex25, utf8ToBytes as utf8ToBytes4 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex24, utf8ToBytes as utf8ToBytes4 } from "@noble/hashes/utils";
 var AuditorType = /* @__PURE__ */ ((AuditorType2) => {
   AuditorType2[AuditorType2["PRIMARY"] = 0] = "PRIMARY";
   AuditorType2[AuditorType2["REGULATORY"] = 1] = "REGULATORY";
@@ -10929,7 +10001,7 @@ var AuditorKeyDerivation = class {
       auditorType
       // auditorType (non-hardened)
     ];
-    const masterData = hmac2(sha5123, utf8ToBytes4("SIP-MASTER-SEED"), masterSeed);
+    const masterData = hmac2(sha5122, utf8ToBytes4("SIP-MASTER-SEED"), masterSeed);
     let currentKey = new Uint8Array(masterData.slice(0, 32));
     let chainCode = new Uint8Array(masterData.slice(32, 64));
     try {
@@ -10942,9 +10014,9 @@ var AuditorKeyDerivation = class {
         currentKey = new Uint8Array(derived.key);
         chainCode = new Uint8Array(derived.chainCode);
       }
-      const keyHex = `0x${bytesToHex25(currentKey)}`;
-      const hashBytes = sha25619(currentKey);
-      const hash2 = `0x${bytesToHex25(hashBytes)}`;
+      const keyHex = `0x${bytesToHex24(currentKey)}`;
+      const hashBytes = sha25618(currentKey);
+      const hash2 = `0x${bytesToHex24(hashBytes)}`;
       const viewingKey = {
         key: keyHex,
         path,
@@ -11011,7 +10083,7 @@ var AuditorKeyDerivation = class {
       account | this.HARDENED
       // account' (hardened)
     ];
-    const masterData = hmac2(sha5123, utf8ToBytes4("SIP-MASTER-SEED"), masterSeed);
+    const masterData = hmac2(sha5122, utf8ToBytes4("SIP-MASTER-SEED"), masterSeed);
     let commonKey = new Uint8Array(masterData.slice(0, 32));
     let commonChainCode = new Uint8Array(masterData.slice(32, 64));
     try {
@@ -11028,9 +10100,9 @@ var AuditorKeyDerivation = class {
       for (const auditorType of uniqueTypes) {
         const derived = this.deriveChildKey(commonKey, commonChainCode, auditorType);
         try {
-          const keyHex = `0x${bytesToHex25(derived.key)}`;
-          const hashBytes = sha25619(derived.key);
-          const hash2 = `0x${bytesToHex25(hashBytes)}`;
+          const keyHex = `0x${bytesToHex24(derived.key)}`;
+          const hashBytes = sha25618(derived.key);
+          const hash2 = `0x${bytesToHex24(hashBytes)}`;
           const path = this.derivePath(auditorType, account);
           const viewingKey = {
             key: keyHex,
@@ -11095,7 +10167,7 @@ var AuditorKeyDerivation = class {
     }
     const indexView = new DataView(data.buffer, 33, 4);
     indexView.setUint32(0, index, false);
-    const hmacResult = hmac2(sha5123, chainCode, data);
+    const hmacResult = hmac2(sha5122, chainCode, data);
     const childKey = new Uint8Array(hmacResult.slice(0, 32));
     const childChainCode = new Uint8Array(hmacResult.slice(32, 64));
     return {
@@ -11151,7 +10223,7 @@ var AuditorKeyDerivation = class {
 };
 
 // src/auction/sealed-bid.ts
-import { randomBytes as randomBytes15, bytesToHex as bytesToHex26 } from "@noble/hashes/utils";
+import { randomBytes as randomBytes13, bytesToHex as bytesToHex25 } from "@noble/hashes/utils";
 var SealedBidAuction = class {
   /**
    * Create a sealed bid for an auction
@@ -11228,7 +10300,7 @@ var SealedBidAuction = class {
         );
       }
     }
-    const salt = params.salt ?? randomBytes15(32);
+    const salt = params.salt ?? randomBytes13(32);
     const { commitment, blinding } = commit(params.amount, salt);
     const sealedBid = {
       auctionId: params.auctionId,
@@ -11372,7 +10444,7 @@ var SealedBidAuction = class {
    * ```
    */
   revealBid(bid, amount, salt) {
-    const saltHex = `0x${bytesToHex26(salt)}`;
+    const saltHex = `0x${bytesToHex25(salt)}`;
     const isValid = this.verifyBid({
       commitment: bid.commitment,
       amount,
@@ -11857,9 +10929,9 @@ function createSealedBidAuction() {
 }
 
 // src/governance/private-vote.ts
-import { sha256 as sha25620 } from "@noble/hashes/sha256";
+import { sha256 as sha25619 } from "@noble/hashes/sha256";
 import { hkdf as hkdf3 } from "@noble/hashes/hkdf";
-import { bytesToHex as bytesToHex27, hexToBytes as hexToBytes21, randomBytes as randomBytes16, utf8ToBytes as utf8ToBytes5 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex26, hexToBytes as hexToBytes20, randomBytes as randomBytes14, utf8ToBytes as utf8ToBytes5 } 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;
@@ -11896,7 +10968,7 @@ var PrivateVoting = class {
     const { proposalId, choice, weight, encryptionKey, voter = "anonymous" } = params;
     const derivedKey = this.deriveEncryptionKey(encryptionKey, proposalId);
     try {
-      const nonce = randomBytes16(NONCE_SIZE2);
+      const nonce = randomBytes14(NONCE_SIZE2);
       const voteData = {
         proposalId,
         choice,
@@ -11907,11 +10979,11 @@ var PrivateVoting = class {
       const plaintext = utf8ToBytes5(JSON.stringify(voteData));
       const cipher = xchacha20poly13054(derivedKey, nonce);
       const ciphertext = cipher.encrypt(plaintext);
-      const keyHash = sha25620(hexToBytes21(encryptionKey.slice(2)));
+      const keyHash = sha25619(hexToBytes20(encryptionKey.slice(2)));
       return {
-        ciphertext: `0x${bytesToHex27(ciphertext)}`,
-        nonce: `0x${bytesToHex27(nonce)}`,
-        encryptionKeyHash: `0x${bytesToHex27(keyHash)}`,
+        ciphertext: `0x${bytesToHex26(ciphertext)}`,
+        nonce: `0x${bytesToHex26(nonce)}`,
+        encryptionKeyHash: `0x${bytesToHex26(keyHash)}`,
         proposalId,
         voter,
         timestamp: voteData.timestamp
@@ -11957,8 +11029,8 @@ var PrivateVoting = class {
     }
     const derivedKey = this.deriveEncryptionKey(decryptionKey, vote.proposalId);
     try {
-      const keyHash = sha25620(hexToBytes21(decryptionKey.slice(2)));
-      const expectedKeyHash = `0x${bytesToHex27(keyHash)}`;
+      const keyHash = sha25619(hexToBytes20(decryptionKey.slice(2)));
+      const expectedKeyHash = `0x${bytesToHex26(keyHash)}`;
       if (vote.encryptionKeyHash !== expectedKeyHash) {
         throw new CryptoError(
           "Decryption key hash mismatch - this key cannot decrypt this vote",
@@ -11967,9 +11039,9 @@ var PrivateVoting = class {
         );
       }
       const nonceHex = vote.nonce.startsWith("0x") ? vote.nonce.slice(2) : vote.nonce;
-      const nonce = hexToBytes21(nonceHex);
+      const nonce = hexToBytes20(nonceHex);
       const ciphertextHex = vote.ciphertext.startsWith("0x") ? vote.ciphertext.slice(2) : vote.ciphertext;
-      const ciphertext = hexToBytes21(ciphertextHex);
+      const ciphertext = hexToBytes20(ciphertextHex);
       const cipher = xchacha20poly13054(derivedKey, nonce);
       let plaintext;
       try {
@@ -12058,11 +11130,11 @@ var PrivateVoting = class {
    */
   deriveEncryptionKey(key, proposalId) {
     const keyHex = key.startsWith("0x") ? key.slice(2) : key;
-    const keyBytes = hexToBytes21(keyHex);
+    const keyBytes = hexToBytes20(keyHex);
     try {
       const salt = utf8ToBytes5(VOTE_ENCRYPTION_DOMAIN);
       const info = utf8ToBytes5(proposalId);
-      return hkdf3(sha25620, keyBytes, salt, info, 32);
+      return hkdf3(sha25619, keyBytes, salt, info, 32);
     } finally {
       secureWipe(keyBytes);
     }
@@ -12207,21 +11279,21 @@ var PrivateVoting = class {
     const blindings = {};
     for (const [choice, weights] of Object.entries(votesByChoice)) {
       const totalWeight = weights.reduce((sum, w) => sum + w, 0n);
-      const { commitment, blinding } = commit(totalWeight, hexToBytes21(generateBlinding().slice(2)));
+      const { commitment, blinding } = commit(totalWeight, hexToBytes20(generateBlinding().slice(2)));
       tallies[choice] = commitment;
       blindings[choice] = blinding;
     }
     const encryptedBlindings = {};
     for (const [choice, blinding] of Object.entries(blindings)) {
-      const nonce = randomBytes16(NONCE_SIZE2);
+      const nonce = randomBytes14(NONCE_SIZE2);
       const derivedKey = this.deriveEncryptionKey(decryptionKey, `${proposalId}-tally-${choice}`);
       try {
         const cipher = xchacha20poly13054(derivedKey, nonce);
-        const blindingBytes = hexToBytes21(blinding.slice(2));
+        const blindingBytes = hexToBytes20(blinding.slice(2));
         const ciphertext = cipher.encrypt(blindingBytes);
         encryptedBlindings[choice] = {
-          ciphertext: `0x${bytesToHex27(ciphertext)}`,
-          nonce: `0x${bytesToHex27(nonce)}`
+          ciphertext: `0x${bytesToHex26(ciphertext)}`,
+          nonce: `0x${bytesToHex26(nonce)}`
         };
       } finally {
         secureWipe(derivedKey);
@@ -12314,9 +11386,9 @@ var PrivateVoting = class {
     }
     let reconstructedKey = null;
     try {
-      reconstructedKey = hexToBytes21(decryptionShares[0].share.slice(2));
+      reconstructedKey = hexToBytes20(decryptionShares[0].share.slice(2));
       for (let i = 1; i < decryptionShares.length; i++) {
-        const shareBytes = hexToBytes21(decryptionShares[i].share.slice(2));
+        const shareBytes = hexToBytes20(decryptionShares[i].share.slice(2));
         if (shareBytes.length !== reconstructedKey.length) {
           throw new ValidationError(
             "all decryption shares must have the same length",
@@ -12329,7 +11401,7 @@ var PrivateVoting = class {
           reconstructedKey[j] ^= shareBytes[j];
         }
       }
-      const reconstructedKeyHex = `0x${bytesToHex27(reconstructedKey)}`;
+      const reconstructedKeyHex = `0x${bytesToHex26(reconstructedKey)}`;
       const results = {};
       for (const [choice, commitmentPoint] of Object.entries(tally.tallies)) {
         const encBlinding = tally.encryptedBlindings[choice];
@@ -12346,11 +11418,11 @@ var PrivateVoting = class {
         );
         let blindingFactor;
         try {
-          const nonceBytes = hexToBytes21(encBlinding.nonce.slice(2));
-          const ciphertextBytes = hexToBytes21(encBlinding.ciphertext.slice(2));
+          const nonceBytes = hexToBytes20(encBlinding.nonce.slice(2));
+          const ciphertextBytes = hexToBytes20(encBlinding.ciphertext.slice(2));
           const cipher = xchacha20poly13054(derivedKey, nonceBytes);
           const blindingBytes = cipher.decrypt(ciphertextBytes);
-          blindingFactor = `0x${bytesToHex27(blindingBytes)}`;
+          blindingFactor = `0x${bytesToHex26(blindingBytes)}`;
         } catch (e) {
           throw new CryptoError(
             "failed to decrypt blinding factor",
@@ -12370,7 +11442,7 @@ var PrivateVoting = class {
           try {
             const { commitment: testCommit } = commit(
               value,
-              hexToBytes21(blindingFactor.slice(2))
+              hexToBytes20(blindingFactor.slice(2))
             );
             if (testCommit === commitmentPoint) {
               results[choice] = value;
@@ -12570,9 +11642,9 @@ function createPrivateVoting() {
 }
 
 // src/nft/private-nft.ts
-import { sha256 as sha25621 } from "@noble/hashes/sha256";
-import { secp256k1 as secp256k18 } from "@noble/curves/secp256k1";
-import { bytesToHex as bytesToHex28, hexToBytes as hexToBytes22 } from "@noble/hashes/utils";
+import { sha256 as sha25620 } from "@noble/hashes/sha256";
+import { secp256k1 as secp256k17 } from "@noble/curves/secp256k1";
+import { bytesToHex as bytesToHex27, hexToBytes as hexToBytes21 } from "@noble/hashes/utils";
 var PrivateNFT = class {
   /**
    * Create a private ownership record for an NFT
@@ -12658,23 +11730,23 @@ var PrivateNFT = class {
     const { ownership, challenge, stealthPrivateKey } = params;
     try {
       const message = this.createProofMessage(ownership, challenge);
-      const messageHash = sha25621(new TextEncoder().encode(message));
-      const privateKeyBytes = hexToBytes22(stealthPrivateKey.slice(2));
-      const signature = secp256k18.sign(messageHash, privateKeyBytes);
+      const messageHash = sha25620(new TextEncoder().encode(message));
+      const privateKeyBytes = hexToBytes21(stealthPrivateKey.slice(2));
+      const signature = secp256k17.sign(messageHash, privateKeyBytes);
       const zkProof = {
         type: "ownership",
-        proof: `0x${bytesToHex28(signature.toCompactRawBytes())}`,
+        proof: `0x${bytesToHex27(signature.toCompactRawBytes())}`,
         publicInputs: [
-          `0x${bytesToHex28(messageHash)}`
+          `0x${bytesToHex27(messageHash)}`
         ]
       };
-      const stealthHashBytes = sha25621(hexToBytes22(ownership.ownerStealth.address.slice(2)));
+      const stealthHashBytes = sha25620(hexToBytes21(ownership.ownerStealth.address.slice(2)));
       return {
         nftContract: ownership.nftContract,
         tokenId: ownership.tokenId,
         challenge,
         proof: zkProof,
-        stealthHash: `0x${bytesToHex28(stealthHashBytes)}`,
+        stealthHash: `0x${bytesToHex27(stealthHashBytes)}`,
         timestamp: Date.now()
       };
     } catch (e) {
@@ -12716,9 +11788,9 @@ var PrivateNFT = class {
   verifyOwnership(proof) {
     try {
       this.validateOwnershipProof(proof);
-      const signatureBytes = hexToBytes22(proof.proof.proof.slice(2));
-      const signature = secp256k18.Signature.fromCompact(signatureBytes);
-      const messageHash = hexToBytes22(proof.proof.publicInputs[0].slice(2));
+      const signatureBytes = hexToBytes21(proof.proof.proof.slice(2));
+      const signature = secp256k17.Signature.fromCompact(signatureBytes);
+      const messageHash = hexToBytes21(proof.proof.publicInputs[0].slice(2));
       if (signatureBytes.length !== 64) {
         return {
           valid: false,
@@ -12815,12 +11887,12 @@ var PrivateNFT = class {
       chain: nft.chain,
       timestamp: Date.now()
     };
-    const previousOwnerHashBytes = sha25621(hexToBytes22(nft.ownerStealth.address.slice(2)));
+    const previousOwnerHashBytes = sha25620(hexToBytes21(nft.ownerStealth.address.slice(2)));
     const transfer = {
       nftContract: nft.nftContract,
       tokenId: nft.tokenId,
       newOwnerStealth,
-      previousOwnerHash: `0x${bytesToHex28(previousOwnerHashBytes)}`,
+      previousOwnerHash: `0x${bytesToHex27(previousOwnerHashBytes)}`,
       chain: nft.chain,
       timestamp: Date.now()
     };
@@ -12887,8 +11959,8 @@ var PrivateNFT = class {
       );
     }
     const ownedNFTs = [];
-    const scanKeyHex = `0x${bytesToHex28(scanKey)}`;
-    const viewingKeyHex = `0x${bytesToHex28(viewingKey)}`;
+    const scanKeyHex = `0x${bytesToHex27(scanKey)}`;
+    const viewingKeyHex = `0x${bytesToHex27(viewingKey)}`;
     for (const transfer of transfers) {
       try {
         if (!transfer || typeof transfer !== "object") {
@@ -15754,7 +14826,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
    * @see https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/
    */
   buildRawEthereumTx(tx) {
-    const hexToBytes23 = (hex) => {
+    const hexToBytes22 = (hex) => {
       if (!hex || hex === "0x" || hex === "0x0" || hex === "0x00") {
         return new Uint8Array(0);
       }
@@ -15771,21 +14843,21 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
     const isEIP1559 = tx.maxFeePerGas !== void 0 && tx.maxPriorityFeePerGas !== void 0;
     if (isEIP1559) {
       const txData = [
-        hexToBytes23(`0x${tx.chainId.toString(16)}`),
+        hexToBytes22(`0x${tx.chainId.toString(16)}`),
         // chainId
-        hexToBytes23(tx.nonce),
+        hexToBytes22(tx.nonce),
         // nonce
-        hexToBytes23(tx.maxPriorityFeePerGas),
+        hexToBytes22(tx.maxPriorityFeePerGas),
         // maxPriorityFeePerGas
-        hexToBytes23(tx.maxFeePerGas),
+        hexToBytes22(tx.maxFeePerGas),
         // maxFeePerGas
-        hexToBytes23(tx.gasLimit),
+        hexToBytes22(tx.gasLimit),
         // gasLimit
-        hexToBytes23(tx.to),
+        hexToBytes22(tx.to),
         // to
-        hexToBytes23(tx.value),
+        hexToBytes22(tx.value),
         // value
-        hexToBytes23(tx.data),
+        hexToBytes22(tx.data),
         // data
         []
         // accessList (empty)
@@ -15804,19 +14876,19 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
         );
       }
       const txData = [
-        hexToBytes23(tx.nonce),
+        hexToBytes22(tx.nonce),
         // nonce
-        hexToBytes23(tx.gasPrice),
+        hexToBytes22(tx.gasPrice),
         // gasPrice
-        hexToBytes23(tx.gasLimit),
+        hexToBytes22(tx.gasLimit),
         // gasLimit
-        hexToBytes23(tx.to),
+        hexToBytes22(tx.to),
         // to
-        hexToBytes23(tx.value),
+        hexToBytes22(tx.value),
         // value
-        hexToBytes23(tx.data),
+        hexToBytes22(tx.data),
         // data
-        hexToBytes23(`0x${tx.chainId.toString(16)}`),
+        hexToBytes22(`0x${tx.chainId.toString(16)}`),
         // v (chainId for EIP-155)
         new Uint8Array(0),
         // r (empty for unsigned)
@@ -16332,7 +15404,7 @@ function createTrezorAdapter(config) {
 
 // src/wallet/hardware/mock.ts
 import { WalletErrorCode as WalletErrorCode17 } from "@sip-protocol/types";
-import { bytesToHex as bytesToHex29, randomBytes as randomBytes17 } from "@noble/hashes/utils";
+import { bytesToHex as bytesToHex28, randomBytes as randomBytes15 } from "@noble/hashes/utils";
 var MockLedgerAdapter = class extends BaseWalletAdapter {
   chain;
   name = "mock-ledger";
@@ -16577,15 +15649,15 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = randomBytes17(20);
+    const bytes = randomBytes15(20);
     bytes[0] = index;
-    return `0x${bytesToHex29(bytes)}`;
+    return `0x${bytesToHex28(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = randomBytes17(33);
+    const bytes = randomBytes15(33);
     bytes[0] = 2;
     bytes[1] = index;
-    return `0x${bytesToHex29(bytes)}`;
+    return `0x${bytesToHex28(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -16594,7 +15666,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 11;
     }
     sig[64] = 27;
-    return `0x${bytesToHex29(sig)}`;
+    return `0x${bytesToHex28(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -16783,15 +15855,15 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = randomBytes17(20);
+    const bytes = randomBytes15(20);
     bytes[0] = index + 100;
-    return `0x${bytesToHex29(bytes)}`;
+    return `0x${bytesToHex28(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = randomBytes17(33);
+    const bytes = randomBytes15(33);
     bytes[0] = 3;
     bytes[1] = index + 100;
-    return `0x${bytesToHex29(bytes)}`;
+    return `0x${bytesToHex28(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -16800,7 +15872,7 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 17;
     }
     sig[64] = 28;
-    return `0x${bytesToHex29(sig)}`;
+    return `0x${bytesToHex28(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -16816,49 +15888,55 @@ function createMockTrezorAdapter(config) {
 // src/wallet/index.ts
 import { WalletErrorCode as WalletErrorCode18 } from "@sip-protocol/types";
 
+// src/executors/same-chain.ts
+var SolanaSameChainExecutor = class {
+  chain = "solana";
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async execute(params) {
+    const { recipientMetaAddress, amount, token } = params;
+    const { connection, sender, getTokenAccount, signTransaction, getTokenMint: getTokenMint2 } = this.config;
+    const mint = getTokenMint2(token);
+    const senderTokenAccount = await getTokenAccount(mint);
+    const result = await sendPrivateSPLTransfer({
+      connection,
+      sender,
+      senderTokenAccount,
+      recipientMetaAddress,
+      mint,
+      amount,
+      signTransaction
+    });
+    return {
+      txHash: result.txSignature,
+      stealthAddress: result.stealthAddress,
+      ephemeralPublicKey: result.ephemeralPublicKey,
+      explorerUrl: result.explorerUrl,
+      chain: "solana"
+    };
+  }
+  async estimateFee(params) {
+    return estimatePrivateTransferFee(this.config.connection, true);
+  }
+};
+function createSameChainExecutor(chain, config) {
+  switch (chain) {
+    case "solana":
+      return new SolanaSameChainExecutor(config);
+    default:
+      throw new Error(`Same-chain executor not available for chain: ${chain}`);
+  }
+}
+function isSameChainSupported(chain) {
+  return chain === "solana";
+}
+function getSupportedSameChainChains() {
+  return ["solana"];
+}
+
 export {
-  isValidChainId,
-  isValidPrivacyLevel,
-  isValidHex,
-  isValidHexLength,
-  isValidAmount,
-  isNonNegativeAmount,
-  isValidSlippage,
-  isValidStealthMetaAddress,
-  isValidCompressedPublicKey,
-  isValidEd25519PublicKey,
-  isValidPrivateKey,
-  validateAsset,
-  validateIntentInput,
-  validateIntentOutput,
-  validateCreateIntentParams,
-  validateViewingKey,
-  isValidScalar,
-  validateScalar,
-  secureWipe,
-  withSecureBuffer,
-  withSecureBufferSync,
-  secureWipeAll,
-  generateStealthMetaAddress,
-  generateStealthAddress,
-  deriveStealthPrivateKey,
-  checkStealthAddress,
-  encodeStealthMetaAddress,
-  decodeStealthMetaAddress,
-  publicKeyToEthAddress,
-  isEd25519Chain,
-  getCurveForChain,
-  generateEd25519StealthMetaAddress,
-  generateEd25519StealthAddress,
-  deriveEd25519StealthPrivateKey,
-  checkEd25519StealthAddress,
-  ed25519PublicKeyToSolanaAddress,
-  isValidSolanaAddress,
-  solanaAddressToEd25519PublicKey,
-  ed25519PublicKeyToNearAddress,
-  nearAddressToEd25519PublicKey,
-  isValidNearImplicitAddress,
-  isValidNearAccountId,
   commit,
   verifyOpening,
   commitZero,
@@ -16926,8 +16004,8 @@ export {
   supportsWASMSimd,
   supportsWASMBulkMemory,
   checkMobileWASMCompatibility,
-  hexToBytes9 as hexToBytes,
-  bytesToHex11 as bytesToHex,
+  hexToBytes8 as hexToBytes,
+  bytesToHex10 as bytesToHex,
   isBrowser,
   supportsWebWorkers,
   supportsSharedArrayBuffer,
@@ -17067,6 +16145,10 @@ export {
   createMockLedgerAdapter,
   createMockTrezorAdapter,
   WalletErrorCode18 as WalletErrorCode,
+  SolanaSameChainExecutor,
+  createSameChainExecutor,
+  isSameChainSupported,
+  getSupportedSameChainChains,
   PrivacyLevel11 as PrivacyLevel,
   IntentStatus4 as IntentStatus,
   SIP_VERSION3 as SIP_VERSION,