@sip-protocol/sdk 0.3.1 → 0.4.0

package/dist/index.js

@@ -31,9 +31,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ATTESTATION_VERSION: () => ATTESTATION_VERSION,
+  AptosStealthService: () => AptosStealthService,
   BaseWalletAdapter: () => BaseWalletAdapter,
   CHAIN_NUMERIC_IDS: () => CHAIN_NUMERIC_IDS,
+  COSMOS_CHAIN_PREFIXES: () => CHAIN_PREFIXES,
   ComplianceManager: () => ComplianceManager,
+  CosmosStealthService: () => CosmosStealthService,
   CryptoError: () => CryptoError,
   DEFAULT_THRESHOLD: () => DEFAULT_THRESHOLD,
   DEFAULT_TOTAL_ORACLES: () => DEFAULT_TOTAL_ORACLES,
@@ -46,7 +49,7 @@ __export(index_exports, {
   HardwareWalletError: () => HardwareWalletError,
   IntentBuilder: () => IntentBuilder,
   IntentError: () => IntentError,
-  IntentStatus: () => import_types37.IntentStatus,
+  IntentStatus: () => import_types55.IntentStatus,
   LedgerWalletAdapter: () => LedgerWalletAdapter,
   MockEthereumAdapter: () => MockEthereumAdapter,
   MockLedgerAdapter: () => MockLedgerAdapter,
@@ -55,27 +58,27 @@ __export(index_exports, {
   MockSolver: () => MockSolver,
   MockTrezorAdapter: () => MockTrezorAdapter,
   MockWalletAdapter: () => MockWalletAdapter,
-  NATIVE_TOKENS: () => import_types37.NATIVE_TOKENS,
+  NATIVE_TOKENS: () => import_types55.NATIVE_TOKENS,
   NEARIntentsAdapter: () => NEARIntentsAdapter,
   NEARIntentsBackend: () => NEARIntentsBackend,
   NetworkError: () => NetworkError,
   ORACLE_DOMAIN: () => ORACLE_DOMAIN,
   OneClickClient: () => OneClickClient,
-  OneClickDepositMode: () => import_types41.OneClickDepositMode,
-  OneClickErrorCode: () => import_types41.OneClickErrorCode,
-  OneClickSwapStatus: () => import_types41.OneClickSwapStatus,
-  OneClickSwapType: () => import_types41.OneClickSwapType,
+  OneClickDepositMode: () => import_types59.OneClickDepositMode,
+  OneClickErrorCode: () => import_types59.OneClickErrorCode,
+  OneClickSwapStatus: () => import_types59.OneClickSwapStatus,
+  OneClickSwapType: () => import_types59.OneClickSwapType,
   PaymentBuilder: () => PaymentBuilder,
-  PaymentStatus: () => import_types38.PaymentStatus,
-  PrivacyLevel: () => import_types37.PrivacyLevel,
+  PaymentStatus: () => import_types56.PaymentStatus,
+  PrivacyLevel: () => import_types55.PrivacyLevel,
   ProofError: () => ProofError,
   ProofGenerationError: () => ProofGenerationError,
   ProofNotImplementedError: () => ProofNotImplementedError,
-  ProposalStatus: () => import_types39.ProposalStatus,
-  ReportStatus: () => import_types40.ReportStatus,
+  ProposalStatus: () => import_types57.ProposalStatus,
+  ReportStatus: () => import_types58.ReportStatus,
   SIP: () => SIP,
   SIPError: () => SIPError,
-  SIP_VERSION: () => import_types37.SIP_VERSION,
+  SIP_VERSION: () => import_types55.SIP_VERSION,
   STABLECOIN_ADDRESSES: () => STABLECOIN_ADDRESSES,
   STABLECOIN_DECIMALS: () => STABLECOIN_DECIMALS,
   STABLECOIN_INFO: () => STABLECOIN_INFO,
@@ -88,8 +91,8 @@ __export(index_exports, {
   TrezorWalletAdapter: () => TrezorWalletAdapter,
   ValidationError: () => ValidationError,
   WalletError: () => WalletError,
-  WalletErrorCode: () => import_types36.WalletErrorCode,
-  ZcashErrorCode: () => import_types42.ZcashErrorCode,
+  WalletErrorCode: () => import_types54.WalletErrorCode,
+  ZcashErrorCode: () => import_types60.ZcashErrorCode,
   ZcashNativeBackend: () => ZcashNativeBackend,
   ZcashRPCClient: () => ZcashRPCClient,
   ZcashRPCError: () => ZcashRPCError,
@@ -98,17 +101,21 @@ __export(index_exports, {
   addBlindings: () => addBlindings,
   addCommitments: () => addCommitments,
   addOracle: () => addOracle,
+  aptosAddressToAuthKey: () => aptosAddressToAuthKey,
   attachProofs: () => attachProofs,
   base58ToHex: () => base58ToHex,
-  browserBytesToHex: () => bytesToHex7,
-  browserHexToBytes: () => hexToBytes5,
+  browserBytesToHex: () => bytesToHex11,
+  browserHexToBytes: () => hexToBytes9,
+  checkAptosStealthAddress: () => checkAptosStealthAddress,
   checkEd25519StealthAddress: () => checkEd25519StealthAddress,
   checkStealthAddress: () => checkStealthAddress,
   commit: () => commit,
   commitZero: () => commitZero,
   computeAttestationHash: () => computeAttestationHash,
+  computeTweakedKey: () => computeTweakedKey,
   createCommitment: () => createCommitment,
   createEthereumAdapter: () => createEthereumAdapter,
+  createKeySpendOnlyOutput: () => createKeySpendOnlyOutput,
   createLedgerAdapter: () => createLedgerAdapter,
   createMockEthereumAdapter: () => createMockEthereumAdapter,
   createMockEthereumProvider: () => createMockEthereumProvider,
@@ -127,6 +134,7 @@ __export(index_exports, {
   createShieldedPayment: () => createShieldedPayment,
   createSmartRouter: () => createSmartRouter,
   createSolanaAdapter: () => createSolanaAdapter,
+  createTaprootOutput: () => createTaprootOutput,
   createTrezorAdapter: () => createTrezorAdapter,
   createWalletFactory: () => createWalletFactory,
   createZcashClient: () => createZcashClient,
@@ -134,8 +142,10 @@ __export(index_exports, {
   createZcashShieldedService: () => createZcashShieldedService,
   createZcashSwapService: () => createZcashSwapService,
   decodeStealthMetaAddress: () => decodeStealthMetaAddress,
+  decodeTaprootAddress: () => decodeTaprootAddress,
   decryptMemo: () => decryptMemo,
   decryptWithViewing: () => decryptWithViewing,
+  deriveAptosStealthPrivateKey: () => deriveAptosStealthPrivateKey,
   deriveEd25519StealthPrivateKey: () => deriveEd25519StealthPrivateKey,
   deriveOracleId: () => deriveOracleId,
   deriveStealthPrivateKey: () => deriveStealthPrivateKey,
@@ -145,6 +155,7 @@ __export(index_exports, {
   deserializePayment: () => deserializePayment,
   detectEthereumWallets: () => detectEthereumWallets,
   detectSolanaWallets: () => detectSolanaWallets,
+  ed25519PublicKeyToAptosAddress: () => ed25519PublicKeyToAptosAddress,
   ed25519PublicKeyToNearAddress: () => ed25519PublicKeyToNearAddress,
   ed25519PublicKeyToSolanaAddress: () => ed25519PublicKeyToSolanaAddress,
   encodeStealthMetaAddress: () => encodeStealthMetaAddress,
@@ -153,7 +164,10 @@ __export(index_exports, {
   formatStablecoinAmount: () => formatStablecoinAmount,
   fromHex: () => fromHex,
   fromStablecoinUnits: () => fromStablecoinUnits,
+  generateAptosStealthAddress: () => generateAptosStealthAddress,
   generateBlinding: () => generateBlinding,
+  generateCosmosStealthAddress: () => generateCosmosStealthAddress,
+  generateCosmosStealthMetaAddress: () => generateCosmosStealthMetaAddress,
   generateEd25519StealthAddress: () => generateEd25519StealthAddress,
   generateEd25519StealthMetaAddress: () => generateEd25519StealthMetaAddress,
   generateIntentId: () => generateIntentId,
@@ -183,6 +197,7 @@ __export(index_exports, {
   getStablecoinsForChain: () => getStablecoinsForChain,
   getSupportedStablecoins: () => getSupportedStablecoins,
   getTimeRemaining: () => getTimeRemaining,
+  getXOnlyPublicKey: () => getXOnlyPublicKey,
   hasEnoughOracles: () => hasEnoughOracles,
   hasErrorCode: () => hasErrorCode,
   hasRequiredProofs: () => hasRequiredProofs,
@@ -193,14 +208,16 @@ __export(index_exports, {
   isExpired: () => isExpired,
   isNonNegativeAmount: () => isNonNegativeAmount,
   isPaymentExpired: () => isPaymentExpired,
-  isPrivate: () => import_types37.isPrivate,
+  isPrivate: () => import_types55.isPrivate,
   isPrivateWalletAdapter: () => isPrivateWalletAdapter,
   isSIPError: () => isSIPError,
   isStablecoin: () => isStablecoin,
   isStablecoinOnChain: () => isStablecoinOnChain,
   isValidAmount: () => isValidAmount,
+  isValidAptosAddress: () => isValidAptosAddress,
   isValidChainId: () => isValidChainId,
   isValidCompressedPublicKey: () => isValidCompressedPublicKey,
+  isValidCosmosAddress: () => isValidCosmosAddress,
   isValidEd25519PublicKey: () => isValidEd25519PublicKey,
   isValidHex: () => isValidHex,
   isValidHexLength: () => isValidHexLength,
@@ -212,12 +229,17 @@ __export(index_exports, {
   isValidSlippage: () => isValidSlippage,
   isValidSolanaAddress: () => isValidSolanaAddress,
   isValidStealthMetaAddress: () => isValidStealthMetaAddress,
+  isValidTaprootAddress: () => isValidTaprootAddress,
   nearAddressToEd25519PublicKey: () => nearAddressToEd25519PublicKey,
   normalizeAddress: () => normalizeAddress,
   notConnectedError: () => notConnectedError,
   publicKeyToEthAddress: () => publicKeyToEthAddress,
   registerWallet: () => registerWallet,
   removeOracle: () => removeOracle,
+  schnorrSign: () => schnorrSign,
+  schnorrSignHex: () => schnorrSignHex,
+  schnorrVerify: () => schnorrVerify,
+  schnorrVerifyHex: () => schnorrVerifyHex,
   secureWipe: () => secureWipe,
   secureWipeAll: () => secureWipeAll,
   serializeAttestationMessage: () => serializeAttestationMessage,
@@ -226,14 +248,16 @@ __export(index_exports, {
   signAttestationMessage: () => signAttestationMessage,
   solanaAddressToEd25519PublicKey: () => solanaAddressToEd25519PublicKey,
   solanaPublicKeyToHex: () => solanaPublicKeyToHex,
+  stealthKeyToCosmosAddress: () => stealthKeyToCosmosAddress,
   subtractBlindings: () => subtractBlindings,
   subtractCommitments: () => subtractCommitments,
   supportsSharedArrayBuffer: () => supportsSharedArrayBuffer,
-  supportsViewingKey: () => import_types37.supportsViewingKey,
+  supportsViewingKey: () => import_types55.supportsViewingKey,
   supportsWebBluetooth: () => supportsWebBluetooth,
   supportsWebHID: () => supportsWebHID,
   supportsWebUSB: () => supportsWebUSB,
   supportsWebWorkers: () => supportsWebWorkers,
+  taprootAddress: () => taprootAddress,
   toHex: () => toHex,
   toStablecoinUnits: () => toStablecoinUnits,
   trackIntent: () => trackIntent,
@@ -474,7 +498,16 @@ var VALID_CHAIN_IDS = [
   "polygon",
   "arbitrum",
   "optimism",
-  "base"
+  "base",
+  "bitcoin",
+  "aptos",
+  "sui",
+  "cosmos",
+  "osmosis",
+  "injective",
+  "celestia",
+  "sei",
+  "dydx"
 ];
 function isValidChainId(chain) {
   return VALID_CHAIN_IDS.includes(chain);
@@ -671,6 +704,12 @@ function isValidNearAddressFormat(address) {
   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":
@@ -685,6 +724,13 @@ function getChainAddressType(chain) {
       return "near";
     case "zcash":
       return "zcash";
+    case "cosmos":
+    case "osmosis":
+    case "injective":
+    case "celestia":
+    case "sei":
+    case "dydx":
+      return "cosmos";
     default:
       return "unknown";
   }
@@ -728,6 +774,15 @@ function validateAddressForChain(address, chain, field = "address") {
         );
       }
       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;
   }
@@ -779,7 +834,7 @@ function secureWipeAll(...buffers) {
 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`,
+      `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"
     );
   }
@@ -1059,7 +1114,7 @@ function toChecksumAddress(address) {
   return checksummed;
 }
 var ED25519_ORDER = 2n ** 252n + 27742317777372353535851937790883648493n;
-var ED25519_CHAINS = ["solana", "near"];
+var ED25519_CHAINS = ["solana", "near", "aptos", "sui"];
 function isEd25519Chain(chain) {
   return ED25519_CHAINS.includes(chain);
 }
@@ -1144,7 +1199,7 @@ function bigIntToBytesLE(value, length) {
 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`,
+      `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"
     );
   }
@@ -2514,7 +2569,15 @@ var CHAIN_BLOCKCHAIN_MAP = {
   arbitrum: "evm",
   optimism: "evm",
   base: "evm",
-  bitcoin: "bitcoin"
+  bitcoin: "bitcoin",
+  aptos: "aptos",
+  sui: "sui",
+  cosmos: "cosmos",
+  osmosis: "cosmos",
+  injective: "cosmos",
+  celestia: "cosmos",
+  sei: "cosmos",
+  dydx: "cosmos"
 };
 var NEARIntentsAdapter = class {
   client;
@@ -3274,6 +3337,448 @@ function createProductionSIP(config) {
   });
 }
 
+// src/move/aptos.ts
+var import_sha32 = require("@noble/hashes/sha3");
+var import_utils7 = require("@noble/hashes/utils");
+var APTOS_SINGLE_ED25519_SCHEME = 0;
+function ed25519PublicKeyToAptosAddress(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 = (0, import_utils7.hexToBytes)(publicKey.slice(2));
+  const authKeyInput = new Uint8Array(publicKeyBytes.length + 1);
+  authKeyInput.set(publicKeyBytes, 0);
+  authKeyInput[publicKeyBytes.length] = APTOS_SINGLE_ED25519_SCHEME;
+  const addressHash = (0, import_sha32.sha3_256)(authKeyInput);
+  return `0x${(0, import_utils7.bytesToHex)(addressHash)}`;
+}
+function isValidAptosAddress(address) {
+  if (typeof address !== "string" || address.length === 0) {
+    return false;
+  }
+  if (!address.startsWith("0x")) {
+    return false;
+  }
+  const hexPart = address.slice(2);
+  if (hexPart.length !== 64) {
+    return false;
+  }
+  return /^[0-9a-fA-F]{64}$/.test(hexPart);
+}
+function aptosAddressToAuthKey(address) {
+  if (!isValidAptosAddress(address)) {
+    throw new ValidationError(
+      "Invalid Aptos address format (must be 0x-prefixed 64 hex characters)",
+      "address"
+    );
+  }
+  return address.toLowerCase();
+}
+function generateAptosStealthAddress(recipientMetaAddress) {
+  if (recipientMetaAddress.chain !== "aptos") {
+    throw new ValidationError(
+      `Expected chain 'aptos', got '${recipientMetaAddress.chain}'`,
+      "recipientMetaAddress.chain"
+    );
+  }
+  const { stealthAddress, sharedSecret } = generateEd25519StealthAddress(recipientMetaAddress);
+  const aptosAddress = ed25519PublicKeyToAptosAddress(stealthAddress.address);
+  return {
+    stealthAddress: aptosAddress,
+    stealthPublicKey: stealthAddress.address,
+    ephemeralPublicKey: stealthAddress.ephemeralPublicKey,
+    viewTag: stealthAddress.viewTag,
+    sharedSecret
+  };
+}
+function deriveAptosStealthPrivateKey(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+  const recovery = deriveEd25519StealthPrivateKey(
+    stealthAddress,
+    spendingPrivateKey,
+    viewingPrivateKey
+  );
+  const aptosAddress = ed25519PublicKeyToAptosAddress(recovery.stealthAddress);
+  return {
+    ...recovery,
+    aptosAddress
+  };
+}
+function checkAptosStealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+  return checkEd25519StealthAddress(
+    stealthAddress,
+    spendingPrivateKey,
+    viewingPrivateKey
+  );
+}
+var AptosStealthService = class {
+  /**
+   * Generate a stealth address for an Aptos recipient
+   *
+   * @param recipientMetaAddress - Recipient's stealth meta-address
+   * @returns Complete stealth address result
+   */
+  generateStealthAddress(recipientMetaAddress) {
+    return generateAptosStealthAddress(recipientMetaAddress);
+  }
+  /**
+   * Convert an ed25519 public key to Aptos address format
+   *
+   * @param publicKey - 32-byte ed25519 public key
+   * @returns Aptos address string
+   */
+  stealthKeyToAptosAddress(publicKey) {
+    return ed25519PublicKeyToAptosAddress(publicKey);
+  }
+  /**
+   * Derive the private key for a stealth address
+   *
+   * @param stealthAddress - Stealth address data
+   * @param spendingPrivateKey - Recipient's spending private key
+   * @param viewingPrivateKey - Recipient's viewing private key
+   * @returns Recovery data with derived private key
+   */
+  deriveStealthPrivateKey(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+    return deriveAptosStealthPrivateKey(stealthAddress, spendingPrivateKey, viewingPrivateKey);
+  }
+  /**
+   * Check if a stealth address belongs to this recipient
+   *
+   * @param stealthAddress - Stealth address to check
+   * @param spendingPrivateKey - Recipient's spending private key
+   * @param viewingPrivateKey - Recipient's viewing private key
+   * @returns true if the address belongs to this recipient
+   */
+  checkStealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+    return checkAptosStealthAddress(stealthAddress, spendingPrivateKey, viewingPrivateKey);
+  }
+  /**
+   * Validate an Aptos address format
+   *
+   * @param address - Address to validate
+   * @returns true if valid format
+   */
+  isValidAddress(address) {
+    return isValidAptosAddress(address);
+  }
+};
+
+// src/move/sui.ts
+var import_blake2b = require("@noble/hashes/blake2b");
+var import_utils8 = require("@noble/hashes/utils");
+
+// src/cosmos/stealth.ts
+var import_sha2566 = require("@noble/hashes/sha256");
+var import_ripemd160 = require("@noble/hashes/ripemd160");
+var import_utils9 = require("@noble/hashes/utils");
+var import_base = require("@scure/base");
+var CHAIN_PREFIXES = {
+  cosmos: "cosmos",
+  osmosis: "osmo",
+  injective: "inj",
+  celestia: "celestia",
+  sei: "sei",
+  dydx: "dydx"
+};
+var CosmosStealthService = class {
+  /**
+   * Generate a stealth meta-address for a Cosmos chain
+   *
+   * @param chain - Cosmos chain identifier
+   * @param label - Optional human-readable label
+   * @returns Stealth meta-address and private keys
+   * @throws {ValidationError} If chain is invalid
+   *
+   * @example
+   * ```typescript
+   * const service = new CosmosStealthService()
+   * const { metaAddress, spendingPrivateKey, viewingPrivateKey } =
+   *   service.generateStealthMetaAddress('cosmos', 'My Cosmos Wallet')
+   * ```
+   */
+  generateStealthMetaAddress(chain, label) {
+    if (!this.isValidCosmosChain(chain)) {
+      throw new ValidationError(
+        `invalid Cosmos chain '${chain}', must be one of: ${Object.keys(CHAIN_PREFIXES).join(", ")}`,
+        "chain"
+      );
+    }
+    const result = generateStealthMetaAddress("ethereum", label);
+    return {
+      ...result,
+      metaAddress: {
+        ...result.metaAddress,
+        chain
+        // Will be updated in types package
+      }
+    };
+  }
+  /**
+   * Generate a one-time stealth address for a Cosmos chain
+   *
+   * @param spendingPubKey - Recipient's spending public key (33-byte compressed)
+   * @param viewingPubKey - Recipient's viewing public key (33-byte compressed)
+   * @param chain - Cosmos chain identifier
+   * @returns Cosmos stealth address with bech32 encoding
+   * @throws {ValidationError} If keys or chain are invalid
+   *
+   * @example
+   * ```typescript
+   * const service = new CosmosStealthService()
+   * const result = service.generateStealthAddress(
+   *   spendingKey,
+   *   viewingKey,
+   *   'osmosis'
+   * )
+   * console.log(result.stealthAddress) // "osmo1..."
+   * ```
+   */
+  generateStealthAddress(spendingPubKey, viewingPubKey, chain) {
+    if (!this.isValidCosmosChain(chain)) {
+      throw new ValidationError(
+        `invalid Cosmos chain '${chain}', must be one of: ${Object.keys(CHAIN_PREFIXES).join(", ")}`,
+        "chain"
+      );
+    }
+    if (spendingPubKey.length !== 33) {
+      throw new ValidationError(
+        "spendingPubKey must be 33 bytes (compressed secp256k1)",
+        "spendingPubKey"
+      );
+    }
+    if (viewingPubKey.length !== 33) {
+      throw new ValidationError(
+        "viewingPubKey must be 33 bytes (compressed secp256k1)",
+        "viewingPubKey"
+      );
+    }
+    const metaAddress = {
+      spendingKey: `0x${(0, import_utils9.bytesToHex)(spendingPubKey)}`,
+      viewingKey: `0x${(0, import_utils9.bytesToHex)(viewingPubKey)}`,
+      chain: "ethereum"
+      // Use ethereum for secp256k1 generation
+    };
+    const { stealthAddress, sharedSecret } = generateStealthAddress(metaAddress);
+    const cosmosAddress = this.stealthKeyToCosmosAddress(
+      (0, import_utils9.hexToBytes)(stealthAddress.address.slice(2)),
+      CHAIN_PREFIXES[chain]
+    );
+    return {
+      stealthAddress: cosmosAddress,
+      stealthPublicKey: stealthAddress.address,
+      ephemeralPublicKey: stealthAddress.ephemeralPublicKey,
+      viewTag: stealthAddress.viewTag,
+      viewKeyHash: sharedSecret
+    };
+  }
+  /**
+   * Generate stealth address from StealthMetaAddress
+   *
+   * Convenience method that accepts a StealthMetaAddress directly.
+   *
+   * @param recipientMetaAddress - Recipient's stealth meta-address
+   * @param chain - Cosmos chain identifier
+   * @returns Cosmos stealth address with bech32 encoding
+   * @throws {ValidationError} If meta-address or chain are invalid
+   *
+   * @example
+   * ```typescript
+   * const service = new CosmosStealthService()
+   * const result = service.generateStealthAddressFromMeta(metaAddress, 'cosmos')
+   * ```
+   */
+  generateStealthAddressFromMeta(recipientMetaAddress, chain) {
+    const spendingPubKey = (0, import_utils9.hexToBytes)(recipientMetaAddress.spendingKey.slice(2));
+    const viewingPubKey = (0, import_utils9.hexToBytes)(recipientMetaAddress.viewingKey.slice(2));
+    return this.generateStealthAddress(spendingPubKey, viewingPubKey, chain);
+  }
+  /**
+   * Convert stealth public key to Cosmos bech32 address
+   *
+   * Algorithm:
+   * 1. SHA256 hash of compressed public key
+   * 2. RIPEMD160 hash of SHA256 hash
+   * 3. Bech32 encode with chain prefix
+   *
+   * @param publicKey - Compressed secp256k1 public key (33 bytes)
+   * @param prefix - Bech32 address prefix (e.g., "cosmos", "osmo")
+   * @returns Bech32-encoded address
+   * @throws {ValidationError} If public key is invalid
+   *
+   * @example
+   * ```typescript
+   * const service = new CosmosStealthService()
+   * const address = service.stealthKeyToCosmosAddress(pubKey, 'cosmos')
+   * // Returns: "cosmos1abc..."
+   * ```
+   */
+  stealthKeyToCosmosAddress(publicKey, prefix) {
+    if (publicKey.length !== 33) {
+      throw new ValidationError(
+        "public key must be 33 bytes (compressed secp256k1)",
+        "publicKey"
+      );
+    }
+    const sha256Hash = (0, import_sha2566.sha256)(publicKey);
+    const hash160 = (0, import_ripemd160.ripemd160)(sha256Hash);
+    const words = import_base.bech32.toWords(hash160);
+    return import_base.bech32.encode(prefix, words);
+  }
+  /**
+   * Derive stealth private key for recipient to claim funds
+   *
+   * @param stealthAddress - The stealth address to recover (as StealthAddress)
+   * @param spendingPrivateKey - Recipient's spending private key
+   * @param viewingPrivateKey - Recipient's viewing private key
+   * @returns Recovery data with derived private key
+   * @throws {ValidationError} If any input is invalid
+   *
+   * @example
+   * ```typescript
+   * const service = new CosmosStealthService()
+   * const recovery = service.deriveStealthPrivateKey(
+   *   stealthAddress,
+   *   spendingPrivKey,
+   *   viewingPrivKey
+   * )
+   * // Use recovery.privateKey to spend funds
+   * ```
+   */
+  deriveStealthPrivateKey(stealthAddress, spendingPrivateKey, viewingPrivateKey) {
+    return deriveStealthPrivateKey(
+      stealthAddress,
+      spendingPrivateKey,
+      viewingPrivateKey
+    );
+  }
+  /**
+   * Check if a string is a valid Cosmos chain identifier
+   */
+  isValidCosmosChain(chain) {
+    return chain in CHAIN_PREFIXES;
+  }
+  /**
+   * Decode a Cosmos bech32 address to raw hash
+   *
+   * @param address - Bech32-encoded address
+   * @returns Decoded address hash (20 bytes)
+   * @throws {ValidationError} If address is invalid
+   *
+   * @example
+   * ```typescript
+   * const service = new CosmosStealthService()
+   * const { prefix, hash } = service.decodeBech32Address('cosmos1abc...')
+   * ```
+   */
+  decodeBech32Address(address) {
+    try {
+      const decoded = import_base.bech32.decode(address);
+      const hash2 = import_base.bech32.fromWords(decoded.words);
+      if (hash2.length !== 20) {
+        throw new ValidationError(
+          `invalid address hash length: ${hash2.length}, expected 20`,
+          "address"
+        );
+      }
+      return {
+        prefix: decoded.prefix,
+        hash: new Uint8Array(hash2)
+      };
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        throw error;
+      }
+      throw new ValidationError(
+        `invalid bech32 address: ${error instanceof Error ? error.message : "unknown error"}`,
+        "address"
+      );
+    }
+  }
+  /**
+   * Validate a Cosmos bech32 address format
+   *
+   * @param address - Address to validate
+   * @param expectedChain - Optional chain to validate prefix against
+   * @returns true if valid, false otherwise
+   *
+   * @example
+   * ```typescript
+   * const service = new CosmosStealthService()
+   * service.isValidCosmosAddress('cosmos1abc...', 'cosmos') // true
+   * service.isValidCosmosAddress('osmo1xyz...', 'cosmos')   // false (wrong prefix)
+   * ```
+   */
+  isValidCosmosAddress(address, expectedChain) {
+    try {
+      const { prefix, hash: hash2 } = this.decodeBech32Address(address);
+      if (hash2.length !== 20) {
+        return false;
+      }
+      if (expectedChain) {
+        return prefix === CHAIN_PREFIXES[expectedChain];
+      }
+      return Object.values(CHAIN_PREFIXES).includes(prefix);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the chain ID from a bech32 address prefix
+   *
+   * @param address - Bech32-encoded address
+   * @returns Chain ID or null if unknown prefix
+   *
+   * @example
+   * ```typescript
+   * const service = new CosmosStealthService()
+   * service.getChainFromAddress('cosmos1abc...') // 'cosmos'
+   * service.getChainFromAddress('osmo1xyz...')   // 'osmosis'
+   * ```
+   */
+  getChainFromAddress(address) {
+    try {
+      const { prefix } = this.decodeBech32Address(address);
+      for (const [chain, chainPrefix] of Object.entries(CHAIN_PREFIXES)) {
+        if (chainPrefix === prefix) {
+          return chain;
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+function generateCosmosStealthMetaAddress(chain, label) {
+  const service = new CosmosStealthService();
+  return service.generateStealthMetaAddress(chain, label);
+}
+function generateCosmosStealthAddress(spendingPubKey, viewingPubKey, chain) {
+  const service = new CosmosStealthService();
+  return service.generateStealthAddress(spendingPubKey, viewingPubKey, chain);
+}
+function stealthKeyToCosmosAddress(publicKey, prefix) {
+  const service = new CosmosStealthService();
+  return service.stealthKeyToCosmosAddress(publicKey, prefix);
+}
+function isValidCosmosAddress(address, expectedChain) {
+  const service = new CosmosStealthService();
+  return service.isValidCosmosAddress(address, expectedChain);
+}
+
+// src/cosmos/ibc-stealth.ts
+var import_utils10 = require("@noble/hashes/utils");
+var import_secp256k13 = require("@noble/curves/secp256k1");
+var import_sha2567 = require("@noble/hashes/sha256");
+
 // src/proofs/interface.ts
 var ProofGenerationError = class extends Error {
   proofType;
@@ -3287,8 +3792,8 @@ var ProofGenerationError = class extends Error {
 };
 
 // src/proofs/mock.ts
-var import_sha2566 = require("@noble/hashes/sha256");
-var import_utils7 = require("@noble/hashes/utils");
+var import_sha2568 = require("@noble/hashes/sha256");
+var import_utils11 = require("@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
@@ -3453,22 +3958,22 @@ var MockProofProvider = class {
       { type: proofType, params },
       (_, v) => typeof v === "bigint" ? v.toString() : v
     );
-    const hash2 = (0, import_sha2566.sha256)(new TextEncoder().encode(input));
-    const random = (0, import_utils7.randomBytes)(16);
+    const hash2 = (0, import_sha2568.sha256)(new TextEncoder().encode(input));
+    const random = (0, import_utils11.randomBytes)(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}${(0, import_utils7.bytesToHex)(combined.slice(4))}`;
+    return `${MOCK_PROOF_PREFIX}${(0, import_utils11.bytesToHex)(combined.slice(4))}`;
   }
   hashToHex(data) {
-    const hash2 = (0, import_sha2566.sha256)(new TextEncoder().encode(data));
-    return `0x${(0, import_utils7.bytesToHex)(hash2)}`;
+    const hash2 = (0, import_sha2568.sha256)(new TextEncoder().encode(data));
+    return `0x${(0, import_utils11.bytesToHex)(hash2)}`;
   }
 };
 
 // src/proofs/browser-utils.ts
-function hexToBytes5(hex) {
+function hexToBytes9(hex) {
   const h = hex.startsWith("0x") ? hex.slice(2) : hex;
   if (h.length === 0) return new Uint8Array(0);
   if (h.length % 2 !== 0) {
@@ -3480,7 +3985,7 @@ function hexToBytes5(hex) {
   }
   return bytes;
 }
-function bytesToHex7(bytes) {
+function bytesToHex11(bytes) {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 function isBrowser() {
@@ -3522,18 +4027,34 @@ var CHAIN_NUMERIC_IDS = {
   // Non-standard, SIP-specific
   near: 502,
   // Non-standard, SIP-specific
-  zcash: 503
+  zcash: 503,
+  // Non-standard, SIP-specific
+  aptos: 504,
+  // Non-standard, SIP-specific
+  sui: 505,
+  // Non-standard, SIP-specific
+  cosmos: 506,
+  // Non-standard, SIP-specific (Cosmos Hub)
+  osmosis: 507,
+  // Non-standard, SIP-specific
+  injective: 508,
+  // Non-standard, SIP-specific
+  celestia: 509,
+  // Non-standard, SIP-specific
+  sei: 510,
+  // Non-standard, SIP-specific
+  dydx: 511
   // Non-standard, SIP-specific
 };
 
 // src/oracle/verification.ts
 var import_ed255192 = require("@noble/curves/ed25519");
-var import_sha2568 = require("@noble/hashes/sha256");
-var import_utils9 = require("@noble/hashes/utils");
+var import_sha25610 = require("@noble/hashes/sha256");
+var import_utils13 = require("@noble/hashes/utils");
 
 // src/oracle/serialization.ts
-var import_sha2567 = require("@noble/hashes/sha256");
-var import_utils8 = require("@noble/hashes/utils");
+var import_sha2569 = require("@noble/hashes/sha256");
+var import_utils12 = require("@noble/hashes/utils");
 function serializeAttestationMessage(message) {
   const buffer = new Uint8Array(197);
   const view = new DataView(buffer.buffer);
@@ -3576,19 +4097,19 @@ function deserializeAttestationMessage(bytes) {
   const version = bytes[offset++];
   const chainId = view.getUint32(offset, false);
   offset += 4;
-  const intentHash = `0x${(0, import_utils8.bytesToHex)(bytes.slice(offset, offset + 32))}`;
+  const intentHash = `0x${(0, import_utils12.bytesToHex)(bytes.slice(offset, offset + 32))}`;
   offset += 32;
-  const recipient = `0x${(0, import_utils8.bytesToHex)(bytes.slice(offset, offset + 32))}`;
+  const recipient = `0x${(0, import_utils12.bytesToHex)(bytes.slice(offset, offset + 32))}`;
   offset += 32;
   const amount = bytesToBigint(bytes.slice(offset, offset + 16));
   offset += 16;
-  const assetId = `0x${(0, import_utils8.bytesToHex)(bytes.slice(offset, offset + 32))}`;
+  const assetId = `0x${(0, import_utils12.bytesToHex)(bytes.slice(offset, offset + 32))}`;
   offset += 32;
-  const txHash = `0x${(0, import_utils8.bytesToHex)(bytes.slice(offset, offset + 32))}`;
+  const txHash = `0x${(0, import_utils12.bytesToHex)(bytes.slice(offset, offset + 32))}`;
   offset += 32;
   const blockNumber = view.getBigUint64(offset, false);
   offset += 8;
-  const blockHash = `0x${(0, import_utils8.bytesToHex)(bytes.slice(offset, offset + 32))}`;
+  const blockHash = `0x${(0, import_utils12.bytesToHex)(bytes.slice(offset, offset + 32))}`;
   offset += 32;
   const timestamp = Number(view.getBigUint64(offset, false));
   return {
@@ -3605,12 +4126,12 @@ function deserializeAttestationMessage(bytes) {
   };
 }
 function computeAttestationHash(message) {
-  const domain = (0, import_utils8.utf8ToBytes)(ORACLE_DOMAIN);
+  const domain = (0, import_utils12.utf8ToBytes)(ORACLE_DOMAIN);
   const messageBytes = serializeAttestationMessage(message);
   const toHash = new Uint8Array(domain.length + messageBytes.length);
   toHash.set(domain, 0);
   toHash.set(messageBytes, domain.length);
-  return (0, import_sha2567.sha256)(toHash);
+  return (0, import_sha2569.sha256)(toHash);
 }
 function getChainNumericId(chain) {
   const id = CHAIN_NUMERIC_IDS[chain];
@@ -3621,7 +4142,7 @@ function getChainNumericId(chain) {
 }
 function normalizeToBytes(hex, length, field) {
   const stripped = hex.startsWith("0x") ? hex.slice(2) : hex;
-  const bytes = (0, import_utils8.hexToBytes)(stripped);
+  const bytes = (0, import_utils12.hexToBytes)(stripped);
   if (bytes.length === length) {
     return bytes;
   }
@@ -3654,9 +4175,9 @@ function bytesToBigint(bytes) {
 
 // src/oracle/verification.ts
 function deriveOracleId(publicKey) {
-  const keyBytes = typeof publicKey === "string" ? (0, import_utils9.hexToBytes)(publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey) : publicKey;
-  const hash2 = (0, import_sha2568.sha256)(keyBytes);
-  return `0x${(0, import_utils9.bytesToHex)(hash2)}`;
+  const keyBytes = typeof publicKey === "string" ? (0, import_utils13.hexToBytes)(publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey) : publicKey;
+  const hash2 = (0, import_sha25610.sha256)(keyBytes);
+  return `0x${(0, import_utils13.bytesToHex)(hash2)}`;
 }
 function verifyAttestation(attestation, registry) {
   const { message, signatures } = attestation;
@@ -3686,10 +4207,10 @@ function verifyAttestation(attestation, registry) {
       continue;
     }
     try {
-      const publicKeyBytes = (0, import_utils9.hexToBytes)(
+      const publicKeyBytes = (0, import_utils13.hexToBytes)(
         oracle.publicKey.startsWith("0x") ? oracle.publicKey.slice(2) : oracle.publicKey
       );
-      const signatureBytes = (0, import_utils9.hexToBytes)(
+      const signatureBytes = (0, import_utils13.hexToBytes)(
         sig.signature.startsWith("0x") ? sig.signature.slice(2) : sig.signature
       );
       const isValid = import_ed255192.ed25519.verify(signatureBytes, messageHash, publicKeyBytes);
@@ -3714,10 +4235,10 @@ function verifyAttestation(attestation, registry) {
 }
 function verifyOracleSignature(signature, messageHash, oracle) {
   try {
-    const publicKeyBytes = (0, import_utils9.hexToBytes)(
+    const publicKeyBytes = (0, import_utils13.hexToBytes)(
       oracle.publicKey.startsWith("0x") ? oracle.publicKey.slice(2) : oracle.publicKey
     );
-    const signatureBytes = (0, import_utils9.hexToBytes)(
+    const signatureBytes = (0, import_utils13.hexToBytes)(
       signature.signature.startsWith("0x") ? signature.signature.slice(2) : signature.signature
     );
     return import_ed255192.ed25519.verify(signatureBytes, messageHash, publicKeyBytes);
@@ -3731,7 +4252,7 @@ function signAttestationMessage(messageHash, privateKey) {
   const oracleId = deriveOracleId(publicKey);
   return {
     oracleId,
-    signature: `0x${(0, import_utils9.bytesToHex)(signature)}`
+    signature: `0x${(0, import_utils13.bytesToHex)(signature)}`
   };
 }
 function createOracleRegistry(config = {}) {
@@ -3783,14 +4304,14 @@ function hasEnoughOracles(registry) {
 }
 
 // src/index.ts
-var import_types37 = require("@sip-protocol/types");
-var import_types38 = require("@sip-protocol/types");
-var import_types39 = require("@sip-protocol/types");
-var import_types40 = require("@sip-protocol/types");
+var import_types55 = require("@sip-protocol/types");
+var import_types56 = require("@sip-protocol/types");
+var import_types57 = require("@sip-protocol/types");
+var import_types58 = require("@sip-protocol/types");
 
 // src/solver/mock-solver.ts
 var import_types7 = require("@sip-protocol/types");
-var import_utils10 = require("@noble/hashes/utils");
+var import_utils14 = require("@noble/hashes/utils");
 var MockSolver = class {
   info;
   capabilities;
@@ -3872,7 +4393,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-${(0, import_utils10.bytesToHex)((0, import_utils10.randomBytes)(8))}`;
+    const quoteId = `quote-${(0, import_utils14.bytesToHex)((0, import_utils14.randomBytes)(8))}`;
     const now = Math.floor(Date.now() / 1e3);
     const quote = {
       quoteId,
@@ -3883,7 +4404,7 @@ var MockSolver = class {
       expiry: now + 60,
       // Quote valid for 1 minute
       fee: feeAmount,
-      signature: `0x${(0, import_utils10.bytesToHex)((0, import_utils10.randomBytes)(64))}`,
+      signature: `0x${(0, import_utils14.bytesToHex)((0, import_utils14.randomBytes)(64))}`,
       // Mock signature
       validUntil: now + 60,
       estimatedGas: 200000n
@@ -3920,7 +4441,7 @@ var MockSolver = class {
         error: status.error
       };
     }
-    const txHash = `0x${(0, import_utils10.bytesToHex)((0, import_utils10.randomBytes)(32))}`;
+    const txHash = `0x${(0, import_utils14.bytesToHex)((0, import_utils14.randomBytes)(32))}`;
     status.status = "completed";
     status.txHash = txHash;
     return {
@@ -3930,10 +4451,10 @@ var MockSolver = class {
       txHash: intent.privacyLevel === "transparent" ? txHash : void 0,
       fulfillmentProof: {
         type: "fulfillment",
-        proof: `0x${(0, import_utils10.bytesToHex)((0, import_utils10.randomBytes)(128))}`,
+        proof: `0x${(0, import_utils14.bytesToHex)((0, import_utils14.randomBytes)(128))}`,
         publicInputs: [
-          `0x${(0, import_utils10.bytesToHex)(new TextEncoder().encode(intent.intentId))}`,
-          `0x${(0, import_utils10.bytesToHex)(new TextEncoder().encode(quote.quoteId))}`
+          `0x${(0, import_utils14.bytesToHex)(new TextEncoder().encode(intent.intentId))}`,
+          `0x${(0, import_utils14.bytesToHex)(new TextEncoder().encode(quote.quoteId))}`
         ]
       },
       fulfilledAt: Math.floor(Date.now() / 1e3)
@@ -3971,7 +4492,7 @@ function createMockSolver(config) {
 }
 
 // src/index.ts
-var import_types41 = require("@sip-protocol/types");
+var import_types59 = require("@sip-protocol/types");
 
 // src/settlement/interface.ts
 var SwapStatus = /* @__PURE__ */ ((SwapStatus2) => {
@@ -4699,6 +5220,15 @@ var NEARIntentsBackend = class {
         "senderAddress"
       );
     }
+    if (params.slippageTolerance !== void 0) {
+      if (params.slippageTolerance < 0 || params.slippageTolerance > 1e4) {
+        throw new ValidationError(
+          "slippageTolerance must be between 0-10000 basis points (0-100%)",
+          "slippageTolerance",
+          { provided: params.slippageTolerance, validRange: "0-10000" }
+        );
+      }
+    }
     if (!this.capabilities.supportedSourceChains.includes(params.fromChain)) {
       throw new ValidationError(
         `Source chain ${params.fromChain} is not supported`,
@@ -5068,7 +5598,7 @@ function createZcashNativeBackend(config) {
 
 // src/settlement/backends/direct-chain.ts
 var import_types10 = require("@sip-protocol/types");
-var import_utils11 = require("@noble/hashes/utils");
+var import_utils15 = require("@noble/hashes/utils");
 var DEFAULT_GAS_FEES = {
   ethereum: 21000n * 50n * 1000000000n,
   // 21k gas * 50 gwei = 0.00105 ETH
@@ -5086,8 +5616,24 @@ var DEFAULT_GAS_FEES = {
   // 21k gas * 0.001 gwei ETH = 21 gwei = 21e6 wei
   base: 2100000000n,
   // 21k gas * 0.1 gwei ETH = 2100 gwei = 2.1e9 wei
-  bitcoin: 10000n
+  bitcoin: 10000n,
   // 10000 sats = 0.0001 BTC (estimate for 1 input, 2 outputs)
+  aptos: 100n,
+  // 0.000001 APT in octas (gas units)
+  sui: 1000n,
+  // 0.000001 SUI in MIST
+  cosmos: 5000n,
+  // 0.005 ATOM in uatom
+  osmosis: 5000n,
+  // 0.005 OSMO in uosmo
+  injective: 5000n,
+  // 0.000005 INJ in inj (18 decimals)
+  celestia: 5000n,
+  // 0.005 TIA in utia
+  sei: 5000n,
+  // 0.005 SEI in usei
+  dydx: 5000n
+  // 0.000005 DYDX in dydx (18 decimals)
 };
 
 // src/zcash/rpc-client.ts
@@ -6372,12 +6918,300 @@ function createZcashSwapService(config) {
 var import_types14 = require("@sip-protocol/types");
 
 // src/index.ts
-var import_types42 = require("@sip-protocol/types");
+var import_types60 = require("@sip-protocol/types");
+
+// src/bitcoin/taproot.ts
+var import_secp256k14 = require("@noble/curves/secp256k1");
+var import_sha25611 = require("@noble/hashes/sha256");
+var import_utils16 = require("@noble/hashes/utils");
+var BECH32_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var BECH32_GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function taggedHash(tag, data) {
+  const tagHash = (0, import_sha25611.sha256)(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 (0, import_sha25611.sha256)(taggedData);
+}
+function schnorrSign(message, privateKey, auxRand) {
+  if (message.length !== 32) {
+    throw new ValidationError("message must be 32 bytes", "message");
+  }
+  if (privateKey.length !== 32) {
+    throw new ValidationError("privateKey must be 32 bytes", "privateKey");
+  }
+  if (auxRand && auxRand.length !== 32) {
+    throw new ValidationError("auxRand must be 32 bytes if provided", "auxRand");
+  }
+  return import_secp256k14.schnorr.sign(message, privateKey, auxRand);
+}
+function schnorrVerify(signature, message, publicKey) {
+  if (signature.length !== 64) {
+    throw new ValidationError("signature must be 64 bytes", "signature");
+  }
+  if (message.length !== 32) {
+    throw new ValidationError("message must be 32 bytes", "message");
+  }
+  if (publicKey.length !== 32) {
+    throw new ValidationError("publicKey must be 32 bytes (x-only)", "publicKey");
+  }
+  try {
+    return import_secp256k14.schnorr.verify(signature, message, publicKey);
+  } catch {
+    return false;
+  }
+}
+function getXOnlyPublicKey(privateKey) {
+  if (privateKey.length !== 32) {
+    throw new ValidationError("privateKey must be 32 bytes", "privateKey");
+  }
+  const publicKey = import_secp256k14.secp256k1.getPublicKey(privateKey, false);
+  return publicKey.slice(1, 33);
+}
+function computeTweakedKey(internalKey, merkleRoot) {
+  if (internalKey.length !== 32) {
+    throw new ValidationError("internalKey must be 32 bytes (x-only)", "internalKey");
+  }
+  if (merkleRoot && merkleRoot.length !== 32) {
+    throw new ValidationError("merkleRoot must be 32 bytes if provided", "merkleRoot");
+  }
+  const tweakData = merkleRoot ? new Uint8Array([...internalKey, ...merkleRoot]) : internalKey;
+  const tweak = taggedHash("TapTweak", tweakData);
+  const tweakScalar = BigInt("0x" + (0, import_utils16.bytesToHex)(tweak)) % import_secp256k14.secp256k1.CURVE.n;
+  const internalPoint = import_secp256k14.secp256k1.ProjectivePoint.fromHex(
+    "02" + (0, import_utils16.bytesToHex)(internalKey)
+  );
+  const tweakPoint = import_secp256k14.secp256k1.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" + (0, import_utils16.bytesToHex)(yCoord));
+  const parity = Number(yBigInt & 1n);
+  return {
+    tweakedKey: xOnly,
+    parity
+  };
+}
+function createTaprootOutput(internalKey, scripts) {
+  if (internalKey.length !== 32) {
+    throw new ValidationError("internalKey must be 32 bytes (x-only)", "internalKey");
+  }
+  let merkleRoot;
+  if (scripts && scripts.length > 0) {
+    if (scripts.length === 1) {
+      const script = scripts[0];
+      const leafData = new Uint8Array([
+        script.leafVersion,
+        script.script.length,
+        ...script.script
+      ]);
+      merkleRoot = taggedHash("TapLeaf", leafData);
+    } else {
+      throw new ValidationError(
+        "Multiple tapscripts not yet implemented - use single script or no scripts",
+        "scripts"
+      );
+    }
+  }
+  const { tweakedKey, parity } = computeTweakedKey(internalKey, merkleRoot);
+  return {
+    tweakedKey: `0x${(0, import_utils16.bytesToHex)(tweakedKey)}`,
+    internalKey: `0x${(0, import_utils16.bytesToHex)(internalKey)}`,
+    merkleRoot: merkleRoot ? `0x${(0, import_utils16.bytesToHex)(merkleRoot)}` : void 0,
+    parity
+  };
+}
+function bech32Polymod(values) {
+  let chk = 1;
+  for (const value of values) {
+    const top = chk >> 25;
+    chk = (chk & 33554431) << 5 ^ value;
+    for (let i = 0; i < 5; i++) {
+      if (top >> i & 1) {
+        chk ^= BECH32_GENERATOR[i];
+      }
+    }
+  }
+  return chk;
+}
+function bech32HrpExpand(hrp) {
+  const result = [];
+  for (let i = 0; i < hrp.length; i++) {
+    result.push(hrp.charCodeAt(i) >> 5);
+  }
+  result.push(0);
+  for (let i = 0; i < hrp.length; i++) {
+    result.push(hrp.charCodeAt(i) & 31);
+  }
+  return result;
+}
+function bech32VerifyChecksum(hrp, data) {
+  return bech32Polymod([...bech32HrpExpand(hrp), ...data]) === 734539939;
+}
+function bech32CreateChecksum(hrp, data) {
+  const values = [...bech32HrpExpand(hrp), ...data, 0, 0, 0, 0, 0, 0];
+  const polymod = bech32Polymod(values) ^ 734539939;
+  const checksum = [];
+  for (let i = 0; i < 6; i++) {
+    checksum.push(polymod >> 5 * (5 - i) & 31);
+  }
+  return checksum;
+}
+function convertBits(data, fromBits, toBits, pad) {
+  let acc = 0;
+  let bits = 0;
+  const result = [];
+  const maxv = (1 << toBits) - 1;
+  for (const value of data) {
+    if (value < 0 || value >> fromBits !== 0) {
+      return null;
+    }
+    acc = acc << fromBits | value;
+    bits += fromBits;
+    while (bits >= toBits) {
+      bits -= toBits;
+      result.push(acc >> bits & maxv);
+    }
+  }
+  if (pad) {
+    if (bits > 0) {
+      result.push(acc << toBits - bits & maxv);
+    }
+  } else if (bits >= fromBits || acc << toBits - bits & maxv) {
+    return null;
+  }
+  return result;
+}
+function taprootAddress(tweakedKey, network = "mainnet") {
+  if (tweakedKey.length !== 32) {
+    throw new ValidationError("tweakedKey must be 32 bytes", "tweakedKey");
+  }
+  const hrp = network === "mainnet" ? "bc" : network === "testnet" ? "tb" : "bcrt";
+  const version = 1;
+  const words = convertBits(tweakedKey, 8, 5, true);
+  if (!words) {
+    throw new ValidationError("Failed to convert tweaked key to bech32 format", "tweakedKey");
+  }
+  const data = [version, ...words];
+  const checksum = bech32CreateChecksum(hrp, data);
+  const combined = [...data, ...checksum];
+  let result = hrp + "1";
+  for (const value of combined) {
+    result += BECH32_CHARSET[value];
+  }
+  return result;
+}
+function decodeTaprootAddress(address) {
+  if (typeof address !== "string" || address.length < 14 || address.length > 90) {
+    throw new ValidationError("Invalid Taproot address format", "address");
+  }
+  const addressLower = address.toLowerCase();
+  const sepIndex = addressLower.lastIndexOf("1");
+  if (sepIndex === -1 || sepIndex + 7 > addressLower.length) {
+    throw new ValidationError("Invalid Taproot address: no separator", "address");
+  }
+  const hrp = addressLower.slice(0, sepIndex);
+  const dataStr = addressLower.slice(sepIndex + 1);
+  let network;
+  if (hrp === "bc") {
+    network = "mainnet";
+  } else if (hrp === "tb") {
+    network = "testnet";
+  } else if (hrp === "bcrt") {
+    network = "regtest";
+  } else {
+    throw new ValidationError(`Unknown HRP: ${hrp}`, "address");
+  }
+  const data = [];
+  for (const char of dataStr) {
+    const index = BECH32_CHARSET.indexOf(char);
+    if (index === -1) {
+      throw new ValidationError(`Invalid bech32 character: ${char}`, "address");
+    }
+    data.push(index);
+  }
+  if (!bech32VerifyChecksum(hrp, data)) {
+    throw new ValidationError("Invalid Taproot address checksum", "address");
+  }
+  const version = data[0];
+  if (version !== 1) {
+    throw new ValidationError(`Expected witness version 1 (Taproot), got ${version}`, "address");
+  }
+  const program = convertBits(new Uint8Array(data.slice(1, -6)), 5, 8, false);
+  if (!program || program.length !== 32) {
+    throw new ValidationError("Invalid Taproot program length", "address");
+  }
+  return {
+    tweakedKey: new Uint8Array(program),
+    network
+  };
+}
+function createKeySpendOnlyOutput(privateKey, network = "mainnet") {
+  if (!isValidPrivateKey(privateKey)) {
+    throw new ValidationError("privateKey must be a valid 32-byte hex string", "privateKey");
+  }
+  const privKeyBytes = (0, import_utils16.hexToBytes)(privateKey.slice(2));
+  const internalKey = getXOnlyPublicKey(privKeyBytes);
+  const output = createTaprootOutput(internalKey);
+  const tweakedKeyBytes = (0, import_utils16.hexToBytes)(output.tweakedKey.slice(2));
+  const address = taprootAddress(tweakedKeyBytes, network);
+  return {
+    output,
+    address,
+    internalPrivateKey: privateKey
+  };
+}
+function isValidTaprootAddress(address) {
+  try {
+    decodeTaprootAddress(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function schnorrSignHex(message, privateKey, auxRand) {
+  if (!isValidHex(message)) {
+    throw new ValidationError("message must be a hex string", "message");
+  }
+  if (!isValidPrivateKey(privateKey)) {
+    throw new ValidationError("privateKey must be a valid 32-byte hex string", "privateKey");
+  }
+  if (auxRand && !isValidHex(auxRand)) {
+    throw new ValidationError("auxRand must be a hex string", "auxRand");
+  }
+  const messageBytes = (0, import_utils16.hexToBytes)(message.slice(2));
+  const privateKeyBytes = (0, import_utils16.hexToBytes)(privateKey.slice(2));
+  const auxRandBytes = auxRand ? (0, import_utils16.hexToBytes)(auxRand.slice(2)) : void 0;
+  const signature = schnorrSign(messageBytes, privateKeyBytes, auxRandBytes);
+  return `0x${(0, import_utils16.bytesToHex)(signature)}`;
+}
+function schnorrVerifyHex(signature, message, publicKey) {
+  if (!isValidHex(signature)) {
+    throw new ValidationError("signature must be a hex string", "signature");
+  }
+  if (!isValidHex(message)) {
+    throw new ValidationError("message must be a hex string", "message");
+  }
+  if (!isValidHex(publicKey)) {
+    throw new ValidationError("publicKey must be a hex string", "publicKey");
+  }
+  const signatureBytes = (0, import_utils16.hexToBytes)(signature.slice(2));
+  const messageBytes = (0, import_utils16.hexToBytes)(message.slice(2));
+  const publicKeyBytes = (0, import_utils16.hexToBytes)(publicKey.slice(2));
+  return schnorrVerify(signatureBytes, messageBytes, publicKeyBytes);
+}
+
+// src/bitcoin/silent-payments.ts
+var import_secp256k15 = require("@noble/curves/secp256k1");
+var import_sha25612 = require("@noble/hashes/sha256");
+var import_utils17 = require("@noble/hashes/utils");
 
 // src/payment/payment.ts
 var import_types15 = require("@sip-protocol/types");
-var import_sha2569 = require("@noble/hashes/sha256");
-var import_utils12 = require("@noble/hashes/utils");
+var import_sha25613 = require("@noble/hashes/sha256");
+var import_utils18 = require("@noble/hashes/utils");
 var import_chacha2 = require("@noble/ciphers/chacha.js");
 var import_hkdf2 = require("@noble/hashes/hkdf");
 
@@ -6873,8 +7707,8 @@ async function createShieldedPayment(params, options) {
   let viewingKeyHash;
   if (viewingKey) {
     const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-    const keyBytes = (0, import_utils12.hexToBytes)(keyHex);
-    viewingKeyHash = `0x${(0, import_utils12.bytesToHex)((0, import_sha2569.sha256)(keyBytes))}`;
+    const keyBytes = (0, import_utils18.hexToBytes)(keyHex);
+    viewingKeyHash = `0x${(0, import_utils18.bytesToHex)((0, import_sha25613.sha256)(keyBytes))}`;
   }
   const privacyConfig = getPrivacyConfig(
     privacy,
@@ -6914,7 +7748,7 @@ async function createShieldedPayment(params, options) {
   if (privacy !== import_types15.PrivacyLevel.TRANSPARENT && proofProvider?.isReady) {
     const hexToUint8 = (hex) => {
       const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-      return (0, import_utils12.hexToBytes)(cleanHex);
+      return (0, import_utils18.hexToBytes)(cleanHex);
     };
     const fundingResult = await proofProvider.generateFundingProof({
       balance: amount,
@@ -6941,17 +7775,17 @@ async function createShieldedPayment(params, options) {
 }
 function encryptMemo(memo, viewingKey) {
   const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-  const keyBytes = (0, import_utils12.hexToBytes)(keyHex);
-  const encKey = (0, import_hkdf2.hkdf)(import_sha2569.sha256, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
+  const keyBytes = (0, import_utils18.hexToBytes)(keyHex);
+  const encKey = (0, import_hkdf2.hkdf)(import_sha25613.sha256, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
   try {
-    const nonce = (0, import_utils12.randomBytes)(24);
+    const nonce = (0, import_utils18.randomBytes)(24);
     const cipher = (0, import_chacha2.xchacha20poly1305)(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${(0, import_utils12.bytesToHex)(result)}`;
+    return `0x${(0, import_utils18.bytesToHex)(result)}`;
   } finally {
     secureWipe(keyBytes);
     secureWipe(encKey);
@@ -6959,11 +7793,11 @@ function encryptMemo(memo, viewingKey) {
 }
 function decryptMemo(encryptedMemo, viewingKey) {
   const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
-  const keyBytes = (0, import_utils12.hexToBytes)(keyHex);
-  const encKey = (0, import_hkdf2.hkdf)(import_sha2569.sha256, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
+  const keyBytes = (0, import_utils18.hexToBytes)(keyHex);
+  const encKey = (0, import_hkdf2.hkdf)(import_sha25613.sha256, keyBytes, new Uint8Array(0), new Uint8Array(0), 32);
   try {
     const dataHex = encryptedMemo.startsWith("0x") ? encryptedMemo.slice(2) : encryptedMemo;
-    const data = (0, import_utils12.hexToBytes)(dataHex);
+    const data = (0, import_utils18.hexToBytes)(dataHex);
     const nonce = data.slice(0, 24);
     const ciphertext = data.slice(24);
     const cipher = (0, import_chacha2.xchacha20poly1305)(encKey, nonce);
@@ -7011,9 +7845,9 @@ function getPaymentSummary(payment) {
 
 // src/treasury/treasury.ts
 var import_types16 = require("@sip-protocol/types");
-var import_secp256k13 = require("@noble/curves/secp256k1");
-var import_sha25610 = require("@noble/hashes/sha256");
-var import_utils13 = require("@noble/hashes/utils");
+var import_secp256k16 = require("@noble/curves/secp256k1");
+var import_sha25614 = require("@noble/hashes/sha256");
+var import_utils19 = require("@noble/hashes/utils");
 var DEFAULT_PROPOSAL_TTL = 7 * 24 * 60 * 60;
 var Treasury = class _Treasury {
   config;
@@ -7504,12 +8338,12 @@ var Treasury = class _Treasury {
   }
 };
 function generateTreasuryId() {
-  const bytes = (0, import_utils13.randomBytes)(16);
-  return `treasury_${(0, import_utils13.bytesToHex)(bytes)}`;
+  const bytes = (0, import_utils19.randomBytes)(16);
+  return `treasury_${(0, import_utils19.bytesToHex)(bytes)}`;
 }
 function generateProposalId() {
-  const bytes = (0, import_utils13.randomBytes)(16);
-  return `prop_${(0, import_utils13.bytesToHex)(bytes)}`;
+  const bytes = (0, import_utils19.randomBytes)(16);
+  return `prop_${(0, import_utils19.bytesToHex)(bytes)}`;
 }
 function computeProposalHash(proposal) {
   const data = JSON.stringify({
@@ -7521,13 +8355,13 @@ function computeProposalHash(proposal) {
     createdAt: proposal.createdAt,
     expiresAt: proposal.expiresAt
   }, (_, value) => typeof value === "bigint" ? value.toString() : value);
-  return (0, import_sha25610.sha256)(new TextEncoder().encode(data));
+  return (0, import_sha25614.sha256)(new TextEncoder().encode(data));
 }
 function signMessage(messageHash, privateKey) {
   const keyHex = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
-  const keyBytes = (0, import_utils13.hexToBytes)(keyHex);
+  const keyBytes = (0, import_utils19.hexToBytes)(keyHex);
   try {
-    const signature = import_secp256k13.secp256k1.sign(messageHash, keyBytes);
+    const signature = import_secp256k16.secp256k1.sign(messageHash, keyBytes);
     return `0x${signature.toCompactHex()}`;
   } finally {
     secureWipe(keyBytes);
@@ -7537,9 +8371,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 = (0, import_utils13.hexToBytes)(sigHex);
-    const pubKeyBytes = (0, import_utils13.hexToBytes)(pubKeyHex);
-    return import_secp256k13.secp256k1.verify(sigBytes, messageHash, pubKeyBytes);
+    const sigBytes = (0, import_utils19.hexToBytes)(sigHex);
+    const pubKeyBytes = (0, import_utils19.hexToBytes)(pubKeyHex);
+    return import_secp256k16.secp256k1.verify(sigBytes, messageHash, pubKeyBytes);
   } catch {
     return false;
   }
@@ -7697,7 +8531,7 @@ function validateBatchProposalParams(params, config) {
 
 // src/compliance/compliance-manager.ts
 var import_types17 = require("@sip-protocol/types");
-var import_utils14 = require("@noble/hashes/utils");
+var import_utils20 = require("@noble/hashes/utils");
 var DEFAULTS2 = {
   riskThreshold: 70,
   highValueThreshold: 10000000000n,
@@ -8371,7 +9205,7 @@ var ComplianceManager = class _ComplianceManager {
   }
 };
 function generateId(prefix) {
-  return `${prefix}_${(0, import_utils14.bytesToHex)((0, import_utils14.randomBytes)(12))}`;
+  return `${prefix}_${(0, import_utils20.bytesToHex)((0, import_utils20.randomBytes)(12))}`;
 }
 function validateRegisterAuditorParams(params) {
   if (!params.organization?.trim()) {
@@ -10615,6 +11449,30 @@ function createMockEthereumProvider(config = {}) {
   return provider;
 }
 
+// src/wallet/cosmos/adapter.ts
+var import_types29 = require("@sip-protocol/types");
+
+// src/wallet/cosmos/mock.ts
+var import_types31 = require("@sip-protocol/types");
+
+// src/wallet/bitcoin/adapter.ts
+var import_types34 = require("@sip-protocol/types");
+
+// src/wallet/bitcoin/mock.ts
+var import_types36 = require("@sip-protocol/types");
+
+// src/wallet/aptos/adapter.ts
+var import_types39 = require("@sip-protocol/types");
+
+// src/wallet/aptos/mock.ts
+var import_types41 = require("@sip-protocol/types");
+
+// src/wallet/sui/adapter.ts
+var import_types43 = require("@sip-protocol/types");
+
+// src/wallet/sui/mock.ts
+var import_types45 = require("@sip-protocol/types");
+
 // src/wallet/hardware/types.ts
 var DerivationPath = {
   /** Ethereum: m/44'/60'/0'/0/index */
@@ -10690,7 +11548,7 @@ function getAvailableTransports() {
 }
 
 // src/wallet/hardware/ledger.ts
-var import_types29 = require("@sip-protocol/types");
+var import_types47 = require("@sip-protocol/types");
 var LedgerWalletAdapter = class extends BaseWalletAdapter {
   chain;
   name = "ledger";
@@ -10843,7 +11701,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types29.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types47.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -10854,7 +11712,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types29.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types47.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   // ─── Account Management ─────────────────────────────────────────────────────
@@ -11142,7 +12000,7 @@ function createLedgerAdapter(config) {
 }
 
 // src/wallet/hardware/trezor.ts
-var import_types31 = require("@sip-protocol/types");
+var import_types49 = require("@sip-protocol/types");
 var TrezorWalletAdapter = class extends BaseWalletAdapter {
   chain;
   name = "trezor";
@@ -11288,7 +12146,7 @@ var TrezorWalletAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types31.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types49.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -11299,7 +12157,7 @@ var TrezorWalletAdapter = class extends BaseWalletAdapter {
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances. Use an RPC provider.",
-      import_types31.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types49.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   // ─── Account Management ─────────────────────────────────────────────────────
@@ -11580,8 +12438,8 @@ function createTrezorAdapter(config) {
 }
 
 // src/wallet/hardware/mock.ts
-var import_types33 = require("@sip-protocol/types");
-var import_utils15 = require("@noble/hashes/utils");
+var import_types51 = require("@sip-protocol/types");
+var import_utils21 = require("@noble/hashes/utils");
 var MockLedgerAdapter = class extends BaseWalletAdapter {
   chain;
   name = "mock-ledger";
@@ -11728,7 +12586,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types33.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types51.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -11737,7 +12595,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types33.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types51.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   /**
@@ -11826,15 +12684,15 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = (0, import_utils15.randomBytes)(20);
+    const bytes = (0, import_utils21.randomBytes)(20);
     bytes[0] = index;
-    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils21.bytesToHex)(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = (0, import_utils15.randomBytes)(33);
+    const bytes = (0, import_utils21.randomBytes)(33);
     bytes[0] = 2;
     bytes[1] = index;
-    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils21.bytesToHex)(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -11843,7 +12701,7 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 11;
     }
     sig[64] = 27;
-    return `0x${(0, import_utils15.bytesToHex)(sig)}`;
+    return `0x${(0, import_utils21.bytesToHex)(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -11967,13 +12825,13 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
   async getBalance() {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types33.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types51.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   async getTokenBalance(_asset) {
     throw new WalletError(
       "Hardware wallets do not track balances",
-      import_types33.WalletErrorCode.UNSUPPORTED_OPERATION
+      import_types51.WalletErrorCode.UNSUPPORTED_OPERATION
     );
   }
   async getAccounts(startIndex = 0, count = 5) {
@@ -12032,15 +12890,15 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = (0, import_utils15.randomBytes)(20);
+    const bytes = (0, import_utils21.randomBytes)(20);
     bytes[0] = index + 100;
-    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils21.bytesToHex)(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = (0, import_utils15.randomBytes)(33);
+    const bytes = (0, import_utils21.randomBytes)(33);
     bytes[0] = 3;
     bytes[1] = index + 100;
-    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils21.bytesToHex)(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -12049,7 +12907,7 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
       sig[32 + i] = (data[i % data.length] ?? 0) ^ i * 17;
     }
     sig[64] = 28;
-    return `0x${(0, import_utils15.bytesToHex)(sig)}`;
+    return `0x${(0, import_utils21.bytesToHex)(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -12063,13 +12921,16 @@ function createMockTrezorAdapter(config) {
 }
 
 // src/wallet/index.ts
-var import_types36 = require("@sip-protocol/types");
+var import_types54 = require("@sip-protocol/types");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ATTESTATION_VERSION,
+  AptosStealthService,
   BaseWalletAdapter,
   CHAIN_NUMERIC_IDS,
+  COSMOS_CHAIN_PREFIXES,
   ComplianceManager,
+  CosmosStealthService,
   CryptoError,
   DEFAULT_THRESHOLD,
   DEFAULT_TOTAL_ORACLES,
@@ -12134,17 +12995,21 @@ var import_types36 = require("@sip-protocol/types");
   addBlindings,
   addCommitments,
   addOracle,
+  aptosAddressToAuthKey,
   attachProofs,
   base58ToHex,
   browserBytesToHex,
   browserHexToBytes,
+  checkAptosStealthAddress,
   checkEd25519StealthAddress,
   checkStealthAddress,
   commit,
   commitZero,
   computeAttestationHash,
+  computeTweakedKey,
   createCommitment,
   createEthereumAdapter,
+  createKeySpendOnlyOutput,
   createLedgerAdapter,
   createMockEthereumAdapter,
   createMockEthereumProvider,
@@ -12163,6 +13028,7 @@ var import_types36 = require("@sip-protocol/types");
   createShieldedPayment,
   createSmartRouter,
   createSolanaAdapter,
+  createTaprootOutput,
   createTrezorAdapter,
   createWalletFactory,
   createZcashClient,
@@ -12170,8 +13036,10 @@ var import_types36 = require("@sip-protocol/types");
   createZcashShieldedService,
   createZcashSwapService,
   decodeStealthMetaAddress,
+  decodeTaprootAddress,
   decryptMemo,
   decryptWithViewing,
+  deriveAptosStealthPrivateKey,
   deriveEd25519StealthPrivateKey,
   deriveOracleId,
   deriveStealthPrivateKey,
@@ -12181,6 +13049,7 @@ var import_types36 = require("@sip-protocol/types");
   deserializePayment,
   detectEthereumWallets,
   detectSolanaWallets,
+  ed25519PublicKeyToAptosAddress,
   ed25519PublicKeyToNearAddress,
   ed25519PublicKeyToSolanaAddress,
   encodeStealthMetaAddress,
@@ -12189,7 +13058,10 @@ var import_types36 = require("@sip-protocol/types");
   formatStablecoinAmount,
   fromHex,
   fromStablecoinUnits,
+  generateAptosStealthAddress,
   generateBlinding,
+  generateCosmosStealthAddress,
+  generateCosmosStealthMetaAddress,
   generateEd25519StealthAddress,
   generateEd25519StealthMetaAddress,
   generateIntentId,
@@ -12219,6 +13091,7 @@ var import_types36 = require("@sip-protocol/types");
   getStablecoinsForChain,
   getSupportedStablecoins,
   getTimeRemaining,
+  getXOnlyPublicKey,
   hasEnoughOracles,
   hasErrorCode,
   hasRequiredProofs,
@@ -12235,8 +13108,10 @@ var import_types36 = require("@sip-protocol/types");
   isStablecoin,
   isStablecoinOnChain,
   isValidAmount,
+  isValidAptosAddress,
   isValidChainId,
   isValidCompressedPublicKey,
+  isValidCosmosAddress,
   isValidEd25519PublicKey,
   isValidHex,
   isValidHexLength,
@@ -12248,12 +13123,17 @@ var import_types36 = require("@sip-protocol/types");
   isValidSlippage,
   isValidSolanaAddress,
   isValidStealthMetaAddress,
+  isValidTaprootAddress,
   nearAddressToEd25519PublicKey,
   normalizeAddress,
   notConnectedError,
   publicKeyToEthAddress,
   registerWallet,
   removeOracle,
+  schnorrSign,
+  schnorrSignHex,
+  schnorrVerify,
+  schnorrVerifyHex,
   secureWipe,
   secureWipeAll,
   serializeAttestationMessage,
@@ -12262,6 +13142,7 @@ var import_types36 = require("@sip-protocol/types");
   signAttestationMessage,
   solanaAddressToEd25519PublicKey,
   solanaPublicKeyToHex,
+  stealthKeyToCosmosAddress,
   subtractBlindings,
   subtractCommitments,
   supportsSharedArrayBuffer,
@@ -12270,6 +13151,7 @@ var import_types36 = require("@sip-protocol/types");
   supportsWebHID,
   supportsWebUSB,
   supportsWebWorkers,
+  taprootAddress,
   toHex,
   toStablecoinUnits,
   trackIntent,