@sip-protocol/sdk 0.3.1 → 0.4.0

package/dist/browser.js

@@ -31,10 +31,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var browser_exports = {};
 __export(browser_exports, {
   ATTESTATION_VERSION: () => ATTESTATION_VERSION,
+  AptosStealthService: () => AptosStealthService,
   BaseWalletAdapter: () => BaseWalletAdapter,
   BrowserNoirProvider: () => BrowserNoirProvider,
   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,
@@ -47,7 +50,7 @@ __export(browser_exports, {
   HardwareWalletError: () => HardwareWalletError,
   IntentBuilder: () => IntentBuilder,
   IntentError: () => IntentError,
-  IntentStatus: () => import_types37.IntentStatus,
+  IntentStatus: () => import_types55.IntentStatus,
   LedgerWalletAdapter: () => LedgerWalletAdapter,
   MockEthereumAdapter: () => MockEthereumAdapter,
   MockLedgerAdapter: () => MockLedgerAdapter,
@@ -56,28 +59,28 @@ __export(browser_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,
   ProofWorker: () => ProofWorker,
-  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,
@@ -90,8 +93,8 @@ __export(browser_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,
@@ -100,18 +103,22 @@ __export(browser_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,
   checkMobileWASMCompatibility: () => checkMobileWASMCompatibility,
   checkStealthAddress: () => checkStealthAddress,
   commit: () => commit,
   commitZero: () => commitZero,
   computeAttestationHash: () => computeAttestationHash,
+  computeTweakedKey: () => computeTweakedKey,
   createCommitment: () => createCommitment,
   createEthereumAdapter: () => createEthereumAdapter,
+  createKeySpendOnlyOutput: () => createKeySpendOnlyOutput,
   createLedgerAdapter: () => createLedgerAdapter,
   createMockEthereumAdapter: () => createMockEthereumAdapter,
   createMockEthereumProvider: () => createMockEthereumProvider,
@@ -130,6 +137,7 @@ __export(browser_exports, {
   createShieldedPayment: () => createShieldedPayment,
   createSmartRouter: () => createSmartRouter,
   createSolanaAdapter: () => createSolanaAdapter,
+  createTaprootOutput: () => createTaprootOutput,
   createTrezorAdapter: () => createTrezorAdapter,
   createWalletFactory: () => createWalletFactory,
   createWorkerBlobURL: () => createWorkerBlobURL,
@@ -138,8 +146,10 @@ __export(browser_exports, {
   createZcashShieldedService: () => createZcashShieldedService,
   createZcashSwapService: () => createZcashSwapService,
   decodeStealthMetaAddress: () => decodeStealthMetaAddress,
+  decodeTaprootAddress: () => decodeTaprootAddress,
   decryptMemo: () => decryptMemo,
   decryptWithViewing: () => decryptWithViewing,
+  deriveAptosStealthPrivateKey: () => deriveAptosStealthPrivateKey,
   deriveEd25519StealthPrivateKey: () => deriveEd25519StealthPrivateKey,
   deriveOracleId: () => deriveOracleId,
   deriveStealthPrivateKey: () => deriveStealthPrivateKey,
@@ -151,6 +161,7 @@ __export(browser_exports, {
   detectMobileBrowser: () => detectMobileBrowser,
   detectMobilePlatform: () => detectMobilePlatform,
   detectSolanaWallets: () => detectSolanaWallets,
+  ed25519PublicKeyToAptosAddress: () => ed25519PublicKeyToAptosAddress,
   ed25519PublicKeyToNearAddress: () => ed25519PublicKeyToNearAddress,
   ed25519PublicKeyToSolanaAddress: () => ed25519PublicKeyToSolanaAddress,
   encodeStealthMetaAddress: () => encodeStealthMetaAddress,
@@ -159,7 +170,10 @@ __export(browser_exports, {
   formatStablecoinAmount: () => formatStablecoinAmount,
   fromHex: () => fromHex,
   fromStablecoinUnits: () => fromStablecoinUnits,
+  generateAptosStealthAddress: () => generateAptosStealthAddress,
   generateBlinding: () => generateBlinding,
+  generateCosmosStealthAddress: () => generateCosmosStealthAddress,
+  generateCosmosStealthMetaAddress: () => generateCosmosStealthMetaAddress,
   generateEd25519StealthAddress: () => generateEd25519StealthAddress,
   generateEd25519StealthMetaAddress: () => generateEd25519StealthMetaAddress,
   generateIntentId: () => generateIntentId,
@@ -192,6 +206,7 @@ __export(browser_exports, {
   getStablecoinsForChain: () => getStablecoinsForChain,
   getSupportedStablecoins: () => getSupportedStablecoins,
   getTimeRemaining: () => getTimeRemaining,
+  getXOnlyPublicKey: () => getXOnlyPublicKey,
   hasEnoughOracles: () => hasEnoughOracles,
   hasErrorCode: () => hasErrorCode,
   hasRequiredProofs: () => hasRequiredProofs,
@@ -202,15 +217,17 @@ __export(browser_exports, {
   isExpired: () => isExpired,
   isNonNegativeAmount: () => isNonNegativeAmount,
   isPaymentExpired: () => isPaymentExpired,
-  isPrivate: () => import_types37.isPrivate,
+  isPrivate: () => import_types55.isPrivate,
   isPrivateWalletAdapter: () => isPrivateWalletAdapter,
   isSIPError: () => isSIPError,
   isStablecoin: () => isStablecoin,
   isStablecoinOnChain: () => isStablecoinOnChain,
   isTablet: () => isTablet,
   isValidAmount: () => isValidAmount,
+  isValidAptosAddress: () => isValidAptosAddress,
   isValidChainId: () => isValidChainId,
   isValidCompressedPublicKey: () => isValidCompressedPublicKey,
+  isValidCosmosAddress: () => isValidCosmosAddress,
   isValidEd25519PublicKey: () => isValidEd25519PublicKey,
   isValidHex: () => isValidHex,
   isValidHexLength: () => isValidHexLength,
@@ -222,12 +239,17 @@ __export(browser_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,
@@ -236,17 +258,19 @@ __export(browser_exports, {
   signAttestationMessage: () => signAttestationMessage,
   solanaAddressToEd25519PublicKey: () => solanaAddressToEd25519PublicKey,
   solanaPublicKeyToHex: () => solanaPublicKeyToHex,
+  stealthKeyToCosmosAddress: () => stealthKeyToCosmosAddress,
   subtractBlindings: () => subtractBlindings,
   subtractCommitments: () => subtractCommitments,
   supportsSharedArrayBuffer: () => supportsSharedArrayBuffer,
   supportsTouch: () => supportsTouch,
-  supportsViewingKey: () => import_types37.supportsViewingKey,
+  supportsViewingKey: () => import_types55.supportsViewingKey,
   supportsWASMBulkMemory: () => supportsWASMBulkMemory,
   supportsWASMSimd: () => supportsWASMSimd,
   supportsWebBluetooth: () => supportsWebBluetooth,
   supportsWebHID: () => supportsWebHID,
   supportsWebUSB: () => supportsWebUSB,
   supportsWebWorkers: () => supportsWebWorkers,
+  taprootAddress: () => taprootAddress,
   toHex: () => toHex,
   toStablecoinUnits: () => toStablecoinUnits,
   trackIntent: () => trackIntent,
@@ -487,7 +511,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);
@@ -684,6 +717,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":
@@ -698,6 +737,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";
   }
@@ -741,6 +787,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;
   }
@@ -792,7 +847,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"
     );
   }
@@ -1072,7 +1127,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);
 }
@@ -1157,7 +1212,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"
     );
   }
@@ -2527,7 +2582,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;
@@ -3287,6 +3350,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;
@@ -3300,8 +3805,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
@@ -3466,17 +3971,17 @@ 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)}`;
   }
 };
 
@@ -3755,7 +4260,7 @@ function checkMobileWASMCompatibility() {
     recommendations
   };
 }
-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) {
@@ -3767,7 +4272,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() {
@@ -3809,18 +4314,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);
@@ -3863,19 +4384,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 {
@@ -3892,12 +4413,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];
@@ -3908,7 +4429,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;
   }
@@ -3941,9 +4462,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;
@@ -3973,10 +4494,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);
@@ -4001,10 +4522,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);
@@ -4018,7 +4539,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 = {}) {
@@ -4070,14 +4591,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;
@@ -4159,7 +4680,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,
@@ -4170,7 +4691,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
@@ -4207,7 +4728,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 {
@@ -4217,10 +4738,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)
@@ -4258,7 +4779,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) => {
@@ -4986,6 +5507,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`,
@@ -5355,7 +5885,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
@@ -5373,8 +5903,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
@@ -6659,12 +7205,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");
 
@@ -7160,8 +7994,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,
@@ -7201,7 +8035,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,
@@ -7228,17 +8062,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);
@@ -7246,11 +8080,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);
@@ -7298,9 +8132,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;
@@ -7791,12 +8625,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({
@@ -7808,13 +8642,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);
@@ -7824,9 +8658,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;
   }
@@ -7984,7 +8818,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,
@@ -8658,7 +9492,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()) {
@@ -10902,6 +11736,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 */
@@ -10977,7 +11835,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";
@@ -11130,7 +11988,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
     );
   }
   /**
@@ -11141,7 +11999,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 ─────────────────────────────────────────────────────
@@ -11429,7 +12287,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";
@@ -11575,7 +12433,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
     );
   }
   /**
@@ -11586,7 +12444,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 ─────────────────────────────────────────────────────
@@ -11867,8 +12725,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";
@@ -12015,7 +12873,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
     );
   }
   /**
@@ -12024,7 +12882,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
     );
   }
   /**
@@ -12113,15 +12971,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);
@@ -12130,7 +12988,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));
@@ -12254,13 +13112,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) {
@@ -12319,15 +13177,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);
@@ -12336,7 +13194,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));
@@ -12350,12 +13208,12 @@ function createMockTrezorAdapter(config) {
 }
 
 // src/wallet/index.ts
-var import_types36 = require("@sip-protocol/types");
+var import_types54 = require("@sip-protocol/types");
 
 // src/proofs/browser.ts
 var import_noir_js = require("@noir-lang/noir_js");
 var import_bb = require("@aztec/bb.js");
-var import_secp256k14 = require("@noble/curves/secp256k1");
+var import_secp256k17 = require("@noble/curves/secp256k1");
 
 // src/proofs/circuits/funding_proof.json
 var funding_proof_default = { noir_version: "1.0.0-beta.15+83245db91dcf63420ef4bcbbd85b98f397fee663", hash: "3859649086066977477", abi: { parameters: [{ name: "minimum_required", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "public" }, { name: "asset_id", type: { kind: "field" }, visibility: "public" }, { name: "balance", type: { kind: "integer", sign: "unsigned", width: 64 }, visibility: "private" }, { name: "blinding", type: { kind: "field" }, visibility: "private" }], return_type: { abi_type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "public" }, error_types: { "2900908756532713827": { error_kind: "string", string: "Insufficient balance" }, "15764276373176857197": { error_kind: "string", string: "Stack too deep" }, "15835548349546956319": { error_kind: "string", string: "Field failed to decompose into specified 32 limbs" } } }, bytecode: "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", debug_symbols: "pdrNbhNZEEDhd/E6i66fW1U3rzIaoQAGRYoCCgnSCPHu0x3XMcnCVnA26WLAZ64r/uIO4dfu8/7j09cPt/dfvv3YXf/za/fx4fbu7vbrh7tvn24eb7/dr//1127ZPkjsrvVqJ3m41O7a1svcXfvVTtc/4b9/X+142IfHh/1+e9SLzlr/fvOwv3/cXd8/3d1d7X7e3D09/6Ef32/un6+PNw/r7y5Xu/395/W6Br/c3u236ffVn0cvpx9ai/aDS+P4cMlXj5fTjw/3fnwMu+TxJTy+6qLH8+RzOfn/P/P8RdQ6IDL+LHC8eYOiWRR0+iUFk6RgI08V8nRBtTiD2svP43xVqDOFUj6RWkNOFebpgq/764LLqEsKauzBNcdlBXlv4fh6OFc4t8m5TDY514f9fcFk4UVtInZRweVYmPnOgi7LqcK5V/VQCjIiTr2q5cwhpJKXlNQ8CUPOfD6HHr9ADJ0vZNSrhJ55IpHK18hIr1OJs6cI5ZU9wsa7E26XJY5fqUbMyxIj+TKxjpc9kVqOiVpOfkbOvi7m5JOqi5z8oq35/tdFvft1cfYUb3tdvDlx+nVxPvGm18XZxNteF2cT739d6PoFg9eFvrgd+IsvOarjTyJPJizOvZ3H8Quf5es343/XX918un14fbuoa/9qZ88f/fnjeP643kDK+irNLXS1q8Ov5uFXst5BynoKke15r1ftq/XV+zr6Gn3NvlZf5+G63ZE+X7un3dPuafe0e9o97Z52T7tn3bPuWfese9Y96551z7pn3bPuefe8e9497553z7feuh+PvmZft976AvN5uI6lr9JX7asd/vzwvnZvRP9+9rV7o3vRvehedC+6F92L7kWfL/p80b3oXnYvu5fdS+ur93X0tc+X3cvq6zxca+mr9LV71b3qXnWvulf9fKvPV32+2eeb3Zva136+s5/v7Oc7uze7N7s3u7fe8zAIgzIYgzN0VZZgSIZi6GcuQlkoC2WhLJRlMARDMhQDZV0YhEEZjIGyUlbKSlkpK9swzmyc2TizUTZnYBvGNoxtGGWj7JSdslN2tuGc2Tmzc2Y8ibNnZxuDbQy2ASoZlAflQRlYgiyBlmBLwCVBOdgzvgRggjAJykEZZIIygZngTIAmSBOoSVJO9ow2gZvgTYpyUYacYE5AJ6gT2AnuBHhSlCd7xp6AT9Ank/KkDEBBoEBQMKgYVAwqBnXpsi7OMBiCIRmKR1HGoGJQMagYVAwqBhWDKpSlGHobikHFoCplpYxBxaBiUDGoGFQMKgbVKJsysA0MKgbVKBtlDCoGFYOKQcWgYlAxqLyjKW9pikHFoGJQeVtT3tcUg4pBxaBiUDGoGFQM6qAc7BmDikHFoAbloIxBxaBiUDGoGFQMKgY1KSd7xqBiUDGoSTkpY1AxqBhUDCoGFYOKQS3KxZ4xqBhUDOqkPCljUDGoGFQMKgYVg4ZBW7psizIYgzMMhuBRyVAMlDFoGDQMGgYNgyaUJRiSoRh6G6aUlTIGDYOGQcOgYdAwaBg0pWwLA9vAoGHQjLJRxqBh0DBoGDQMGgYNg+aUnT1j0DBoGDRuLI07S8OgYdAwaBg0DBoGDYM2KA/2jEHDoGHQuM20oIxBw6Bh0DBoGDQMGgYtKSd7xqBh0DBo3HRaUsagYdAwaBg0DBoGDYNWlIs9Y9AwaBg0bkFtUsagYdAwaBg0DBoGDYM2u+zLwiAMymAMXfZlMARDMvBNBwYdg45Bx6ALZXEGvpfBoGPQuRd1oYxBx6Bj0DHoGHQMOgZdKWsxsA0MOgade1E3yhh0DDoGHYOOQcegY9CdsrNnDDoG/fidHfeifvzejvdB533QMejci/qgzHd4jkHHoGPQeR/0Z4OxDVt5bt9XLgzCoAzG4AyDIRiSoRgoJ+WknJSTclJOykk5KSflpFyUi3JRLspFuSgX5aJclIvypDwpT8qbwe2v430zeBgGQ2x/rbwNyVAM8zCMzeBhkMOjxmbwMBiD82cGQzAkQzFQFspCWSgLZXGGwUBZKAtloayUN4OHQRmMgTMr5c3gYUiGYpg9GGWjbJSNslE2tmGc2TizcWajvBk8DGzD2YazDafslJ2yU3bKzjYGZx6ceXDmQXmw58E2BtsYbGNQHpSDclAOysE2gjMHZw7OHJSDPQfbSLaRbCMpJ+WknJSTcrKN5MzJmYszF+Viz8U2im0U2yjKRbkoF+VJebKNyZknZ56cGYNjsufJNibbmL2NwGAswqAMxuAMgyEYkqEYKMvCIAzKYAyUhTIGA4OBwcBgYDAwGBgMpazOMBiCIRkoK2UMBgYDg4HBwGBgMDAYRtmKgW1gMDAYTtkpYzAwGBgMDAYGA4OBwRiUB3vGYGAwMBiD8qCMwcBgYDAwGBgMDAYGIygHe8ZgYDAwGEk5KWMwMBgYDAwGBgODgcFIysWeMRgYDAxGUS7KGAwMBgYDg4HBwGBgMHgfDN4HA4OBwcBg8D4YvA8mBhODicHEYGIwMZgYzKXLuRRDbyMxmBhMoSyUMZgYTAwmBhODicHEYCplVQZjcIbBQFkpYzAxmBhMDCYGE4OJwTTKFgxsA4OJwXTKThmDicHEYGIwMZgYTAymUx7sGYOJwcRgDsqDMgYTg4nBxGBiMDGYGMygHOwZg4nBxGAG5aCMwcRgYjAxmBhMDCYGMykne8ZgYjAxmEW5KGMwMZgYTAwmBhODicGclCd7xmBiMDGY3Ism96KJwcRgYbAwWBgsDBYGa+lyLcGQDMXQ2yjuRUsoY7AwWBgsDBYGC4OFwRLKujAIgzIYA2WljMHCYGGwMFgYLAwWBssomzOwDQwWBot70TLKGCwMFgYLg4XBwmBhsJyys2cMFgYLg8W9aA3KGCwMFgYLg4XBwmBhsIJysGcMFgYLg8W9aAVlDBYGC4OFwcJgYbAwWEk52TMGC4OFweJetIoyBguDhcHCYGGwMFgYrKI82TMGC4OFweJetDBYvA8W74OFweJedC4LgzD0mScGJwYn74Pz2aBvw1be/gnRz5uH25uPd/sf60/et5/NP91/4gfx6y8f//vO7/AvO78/fPu0//z0sN9+aP/in3euH/9Z/45A57+/tx/s/w8=", file_map: { "17": { source: `use crate::field::field_less_than;
@@ -13368,7 +14226,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
    * Derive secp256k1 public key coordinates from a private key
    */
   static derivePublicKey(privateKey) {
-    const uncompressedPubKey = import_secp256k14.secp256k1.getPublicKey(privateKey, false);
+    const uncompressedPubKey = import_secp256k17.secp256k1.getPublicKey(privateKey, false);
     const x = Array.from(uncompressedPubKey.slice(1, 33));
     const y = Array.from(uncompressedPubKey.slice(33, 65));
     return { x, y };
@@ -13581,7 +14439,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
         message: "Proof generated successfully"
       });
       const commitmentHashBytes = returnValue;
-      const commitmentHashHex = bytesToHex7(new Uint8Array(commitmentHashBytes));
+      const commitmentHashHex = bytesToHex11(new Uint8Array(commitmentHashBytes));
       const publicInputs = [
         `0x${params.minimumRequired.toString(16).padStart(16, "0")}`,
         `0x${this.assetIdToField(params.assetId)}`,
@@ -13589,7 +14447,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
       ];
       const proof = {
         type: "funding",
-        proof: `0x${bytesToHex7(proofData.proof)}`,
+        proof: `0x${bytesToHex11(proofData.proof)}`,
         publicInputs
       };
       return { proof, publicInputs };
@@ -13683,7 +14541,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
       ];
       const proof = {
         type: "validity",
-        proof: `0x${bytesToHex7(proofData.proof)}`,
+        proof: `0x${bytesToHex11(proofData.proof)}`,
         publicInputs
       };
       return { proof, publicInputs };
@@ -13783,7 +14641,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
       ];
       const proof = {
         type: "fulfillment",
-        proof: `0x${bytesToHex7(proofData.proof)}`,
+        proof: `0x${bytesToHex11(proofData.proof)}`,
         publicInputs
       };
       return { proof, publicInputs };
@@ -13823,7 +14681,7 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
     }
     try {
       const proofHex = proof.proof.startsWith("0x") ? proof.proof.slice(2) : proof.proof;
-      const proofBytes = hexToBytes5(proofHex);
+      const proofBytes = hexToBytes9(proofHex);
       const isValid = await backend.verifyProof({
         proof: proofBytes,
         publicInputs: proof.publicInputs.map(
@@ -13874,14 +14732,14 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
   }
   async computeCommitmentHash(balance, blindingFactor, assetId) {
     const blindingField = this.bytesToField(blindingFactor);
-    const { sha256: sha25611 } = await import("@noble/hashes/sha256");
+    const { sha256: sha25615 } = await import("@noble/hashes/sha256");
     const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
     const preimage = new Uint8Array([
       ...this.bigintToBytes(balance, 8),
       ...blindingFactor.slice(0, 32),
-      ...hexToBytes5(this.assetIdToField(assetId))
+      ...hexToBytes9(this.assetIdToField(assetId))
     ]);
-    const hash2 = sha25611(preimage);
+    const hash2 = sha25615(preimage);
     const commitmentHash = nobleToHex(hash2);
     return { commitmentHash, blindingField };
   }
@@ -13927,49 +14785,49 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
     return bytes;
   }
   async computeSenderCommitment(senderAddressField, senderBlindingField) {
-    const { sha256: sha25611 } = await import("@noble/hashes/sha256");
+    const { sha256: sha25615 } = await import("@noble/hashes/sha256");
     const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
-    const addressBytes = hexToBytes5(senderAddressField);
-    const blindingBytes = hexToBytes5(senderBlindingField.padStart(64, "0"));
+    const addressBytes = hexToBytes9(senderAddressField);
+    const blindingBytes = hexToBytes9(senderBlindingField.padStart(64, "0"));
     const preimage = new Uint8Array([...addressBytes, ...blindingBytes]);
-    const hash2 = sha25611(preimage);
+    const hash2 = sha25615(preimage);
     const commitmentX = nobleToHex(hash2.slice(0, 16)).padStart(64, "0");
     const commitmentY = nobleToHex(hash2.slice(16, 32)).padStart(64, "0");
     return { commitmentX, commitmentY };
   }
   async computeNullifier(senderSecretField, intentHashField, nonceField) {
-    const { sha256: sha25611 } = await import("@noble/hashes/sha256");
+    const { sha256: sha25615 } = await import("@noble/hashes/sha256");
     const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
-    const secretBytes = hexToBytes5(senderSecretField.padStart(64, "0"));
-    const intentBytes = hexToBytes5(intentHashField);
-    const nonceBytes = hexToBytes5(nonceField.padStart(64, "0"));
+    const secretBytes = hexToBytes9(senderSecretField.padStart(64, "0"));
+    const intentBytes = hexToBytes9(intentHashField);
+    const nonceBytes = hexToBytes9(nonceField.padStart(64, "0"));
     const preimage = new Uint8Array([...secretBytes, ...intentBytes, ...nonceBytes]);
-    const hash2 = sha25611(preimage);
+    const hash2 = sha25615(preimage);
     return nobleToHex(hash2);
   }
   async computeOutputCommitment(outputAmount, outputBlinding) {
-    const { sha256: sha25611 } = await import("@noble/hashes/sha256");
+    const { sha256: sha25615 } = await import("@noble/hashes/sha256");
     const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
     const amountBytes = this.bigintToBytes(outputAmount, 8);
     const blindingBytes = outputBlinding.slice(0, 32);
     const preimage = new Uint8Array([...amountBytes, ...blindingBytes]);
-    const hash2 = sha25611(preimage);
+    const hash2 = sha25615(preimage);
     const commitmentX = nobleToHex(hash2.slice(0, 16)).padStart(64, "0");
     const commitmentY = nobleToHex(hash2.slice(16, 32)).padStart(64, "0");
     return { commitmentX, commitmentY };
   }
   async computeSolverId(solverSecretField) {
-    const { sha256: sha25611 } = await import("@noble/hashes/sha256");
+    const { sha256: sha25615 } = await import("@noble/hashes/sha256");
     const { bytesToHex: nobleToHex } = await import("@noble/hashes/utils");
-    const secretBytes = hexToBytes5(solverSecretField.padStart(64, "0"));
-    const hash2 = sha25611(secretBytes);
+    const secretBytes = hexToBytes9(solverSecretField.padStart(64, "0"));
+    const hash2 = sha25615(secretBytes);
     return nobleToHex(hash2);
   }
   async computeOracleMessageHash(recipient, amount, txHash, blockNumber) {
-    const { sha256: sha25611 } = await import("@noble/hashes/sha256");
-    const recipientBytes = hexToBytes5(this.hexToField(recipient));
+    const { sha256: sha25615 } = await import("@noble/hashes/sha256");
+    const recipientBytes = hexToBytes9(this.hexToField(recipient));
     const amountBytes = this.bigintToBytes(amount, 8);
-    const txHashBytes = hexToBytes5(this.hexToField(txHash));
+    const txHashBytes = hexToBytes9(this.hexToField(txHash));
     const blockBytes = this.bigintToBytes(blockNumber, 8);
     const preimage = new Uint8Array([
       ...recipientBytes,
@@ -13977,11 +14835,11 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
       ...txHashBytes,
       ...blockBytes
     ]);
-    const hash2 = sha25611(preimage);
+    const hash2 = sha25615(preimage);
     return Array.from(hash2);
   }
   getPublicKeyCoordinates(privateKey) {
-    const uncompressedPubKey = import_secp256k14.secp256k1.getPublicKey(privateKey, false);
+    const uncompressedPubKey = import_secp256k17.secp256k1.getPublicKey(privateKey, false);
     const x = Array.from(uncompressedPubKey.slice(1, 33));
     const y = Array.from(uncompressedPubKey.slice(33, 65));
     return { x, y };
@@ -14534,10 +15392,13 @@ var ProofWorker = class _ProofWorker {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ATTESTATION_VERSION,
+  AptosStealthService,
   BaseWalletAdapter,
   BrowserNoirProvider,
   CHAIN_NUMERIC_IDS,
+  COSMOS_CHAIN_PREFIXES,
   ComplianceManager,
+  CosmosStealthService,
   CryptoError,
   DEFAULT_THRESHOLD,
   DEFAULT_TOTAL_ORACLES,
@@ -14603,18 +15464,22 @@ var ProofWorker = class _ProofWorker {
   addBlindings,
   addCommitments,
   addOracle,
+  aptosAddressToAuthKey,
   attachProofs,
   base58ToHex,
   browserBytesToHex,
   browserHexToBytes,
+  checkAptosStealthAddress,
   checkEd25519StealthAddress,
   checkMobileWASMCompatibility,
   checkStealthAddress,
   commit,
   commitZero,
   computeAttestationHash,
+  computeTweakedKey,
   createCommitment,
   createEthereumAdapter,
+  createKeySpendOnlyOutput,
   createLedgerAdapter,
   createMockEthereumAdapter,
   createMockEthereumProvider,
@@ -14633,6 +15498,7 @@ var ProofWorker = class _ProofWorker {
   createShieldedPayment,
   createSmartRouter,
   createSolanaAdapter,
+  createTaprootOutput,
   createTrezorAdapter,
   createWalletFactory,
   createWorkerBlobURL,
@@ -14641,8 +15507,10 @@ var ProofWorker = class _ProofWorker {
   createZcashShieldedService,
   createZcashSwapService,
   decodeStealthMetaAddress,
+  decodeTaprootAddress,
   decryptMemo,
   decryptWithViewing,
+  deriveAptosStealthPrivateKey,
   deriveEd25519StealthPrivateKey,
   deriveOracleId,
   deriveStealthPrivateKey,
@@ -14654,6 +15522,7 @@ var ProofWorker = class _ProofWorker {
   detectMobileBrowser,
   detectMobilePlatform,
   detectSolanaWallets,
+  ed25519PublicKeyToAptosAddress,
   ed25519PublicKeyToNearAddress,
   ed25519PublicKeyToSolanaAddress,
   encodeStealthMetaAddress,
@@ -14662,7 +15531,10 @@ var ProofWorker = class _ProofWorker {
   formatStablecoinAmount,
   fromHex,
   fromStablecoinUnits,
+  generateAptosStealthAddress,
   generateBlinding,
+  generateCosmosStealthAddress,
+  generateCosmosStealthMetaAddress,
   generateEd25519StealthAddress,
   generateEd25519StealthMetaAddress,
   generateIntentId,
@@ -14695,6 +15567,7 @@ var ProofWorker = class _ProofWorker {
   getStablecoinsForChain,
   getSupportedStablecoins,
   getTimeRemaining,
+  getXOnlyPublicKey,
   hasEnoughOracles,
   hasErrorCode,
   hasRequiredProofs,
@@ -14712,8 +15585,10 @@ var ProofWorker = class _ProofWorker {
   isStablecoinOnChain,
   isTablet,
   isValidAmount,
+  isValidAptosAddress,
   isValidChainId,
   isValidCompressedPublicKey,
+  isValidCosmosAddress,
   isValidEd25519PublicKey,
   isValidHex,
   isValidHexLength,
@@ -14725,12 +15600,17 @@ var ProofWorker = class _ProofWorker {
   isValidSlippage,
   isValidSolanaAddress,
   isValidStealthMetaAddress,
+  isValidTaprootAddress,
   nearAddressToEd25519PublicKey,
   normalizeAddress,
   notConnectedError,
   publicKeyToEthAddress,
   registerWallet,
   removeOracle,
+  schnorrSign,
+  schnorrSignHex,
+  schnorrVerify,
+  schnorrVerifyHex,
   secureWipe,
   secureWipeAll,
   serializeAttestationMessage,
@@ -14739,6 +15619,7 @@ var ProofWorker = class _ProofWorker {
   signAttestationMessage,
   solanaAddressToEd25519PublicKey,
   solanaPublicKeyToHex,
+  stealthKeyToCosmosAddress,
   subtractBlindings,
   subtractCommitments,
   supportsSharedArrayBuffer,
@@ -14750,6 +15631,7 @@ var ProofWorker = class _ProofWorker {
   supportsWebHID,
   supportsWebUSB,
   supportsWebWorkers,
+  taprootAddress,
   toHex,
   toStablecoinUnits,
   trackIntent,