@sip-protocol/sdk 0.3.2 → 0.5.0

package/dist/index.js

@@ -31,9 +31,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ATTESTATION_VERSION: () => ATTESTATION_VERSION,
+  AptosStealthService: () => AptosStealthService,
+  AuditorKeyDerivation: () => AuditorKeyDerivation,
+  AuditorType: () => AuditorType,
   BaseWalletAdapter: () => BaseWalletAdapter,
   CHAIN_NUMERIC_IDS: () => CHAIN_NUMERIC_IDS,
+  COSMOS_CHAIN_PREFIXES: () => CHAIN_PREFIXES,
   ComplianceManager: () => ComplianceManager,
+  ComplianceReporter: () => ComplianceReporter,
+  ConditionalDisclosure: () => ConditionalDisclosure,
+  CosmosStealthService: () => CosmosStealthService,
   CryptoError: () => CryptoError,
   DEFAULT_THRESHOLD: () => DEFAULT_THRESHOLD,
   DEFAULT_TOTAL_ORACLES: () => DEFAULT_TOTAL_ORACLES,
@@ -46,7 +53,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 +62,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,
@@ -84,12 +91,13 @@ __export(index_exports, {
   SmartRouter: () => SmartRouter,
   SolanaWalletAdapter: () => SolanaWalletAdapter,
   SwapStatus: () => SwapStatus,
+  ThresholdViewingKey: () => ThresholdViewingKey,
   Treasury: () => Treasury,
   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 +106,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 +139,7 @@ __export(index_exports, {
   createShieldedPayment: () => createShieldedPayment,
   createSmartRouter: () => createSmartRouter,
   createSolanaAdapter: () => createSolanaAdapter,
+  createTaprootOutput: () => createTaprootOutput,
   createTrezorAdapter: () => createTrezorAdapter,
   createWalletFactory: () => createWalletFactory,
   createZcashClient: () => createZcashClient,
@@ -134,8 +147,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 +160,7 @@ __export(index_exports, {
   deserializePayment: () => deserializePayment,
   detectEthereumWallets: () => detectEthereumWallets,
   detectSolanaWallets: () => detectSolanaWallets,
+  ed25519PublicKeyToAptosAddress: () => ed25519PublicKeyToAptosAddress,
   ed25519PublicKeyToNearAddress: () => ed25519PublicKeyToNearAddress,
   ed25519PublicKeyToSolanaAddress: () => ed25519PublicKeyToSolanaAddress,
   encodeStealthMetaAddress: () => encodeStealthMetaAddress,
@@ -153,10 +169,14 @@ __export(index_exports, {
   formatStablecoinAmount: () => formatStablecoinAmount,
   fromHex: () => fromHex,
   fromStablecoinUnits: () => fromStablecoinUnits,
+  generateAptosStealthAddress: () => generateAptosStealthAddress,
   generateBlinding: () => generateBlinding,
+  generateCosmosStealthAddress: () => generateCosmosStealthAddress,
+  generateCosmosStealthMetaAddress: () => generateCosmosStealthMetaAddress,
   generateEd25519StealthAddress: () => generateEd25519StealthAddress,
   generateEd25519StealthMetaAddress: () => generateEd25519StealthMetaAddress,
   generateIntentId: () => generateIntentId,
+  generatePdfReport: () => generatePdfReport,
   generateRandomBytes: () => generateRandomBytes,
   generateStealthAddress: () => generateStealthAddress,
   generateStealthMetaAddress: () => generateStealthMetaAddress,
@@ -183,6 +203,7 @@ __export(index_exports, {
   getStablecoinsForChain: () => getStablecoinsForChain,
   getSupportedStablecoins: () => getSupportedStablecoins,
   getTimeRemaining: () => getTimeRemaining,
+  getXOnlyPublicKey: () => getXOnlyPublicKey,
   hasEnoughOracles: () => hasEnoughOracles,
   hasErrorCode: () => hasErrorCode,
   hasRequiredProofs: () => hasRequiredProofs,
@@ -193,14 +214,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 +235,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 +254,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,
@@ -279,6 +309,14 @@ var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
   ErrorCode2["SIGNATURE_FAILED"] = "SIP_3005";
   ErrorCode2["INVALID_CURVE_POINT"] = "SIP_3006";
   ErrorCode2["INVALID_SCALAR"] = "SIP_3007";
+  ErrorCode2["INVALID_KEY_SIZE"] = "SIP_3008";
+  ErrorCode2["INVALID_ENCRYPTED_DATA"] = "SIP_3009";
+  ErrorCode2["INVALID_COMMITMENT"] = "SIP_3010";
+  ErrorCode2["INVALID_TIME_LOCK"] = "SIP_3011";
+  ErrorCode2["INVALID_SHARE"] = "SIP_3012";
+  ErrorCode2["INVALID_THRESHOLD"] = "SIP_3013";
+  ErrorCode2["CRYPTO_OPERATION_FAILED"] = "SIP_3014";
+  ErrorCode2["INVALID_FORMAT"] = "SIP_3015";
   ErrorCode2["PROOF_FAILED"] = "SIP_4000";
   ErrorCode2["PROOF_GENERATION_FAILED"] = "SIP_4001";
   ErrorCode2["PROOF_VERIFICATION_FAILED"] = "SIP_4002";
@@ -474,7 +512,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 +718,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 +738,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 +788,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 +848,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 +1128,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 +1213,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 +2583,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 +3351,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 +3806,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 +3972,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 +3999,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 +4041,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 +4111,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 +4140,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 +4156,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 +4189,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 +4221,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 +4249,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 +4266,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 +4318,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 +4407,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 +4418,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 +4455,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 +4465,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 +4506,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) => {
@@ -5077,7 +5612,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
@@ -5095,8 +5630,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
@@ -6381,33 +6932,321 @@ function createZcashSwapService(config) {
 var import_types14 = require("@sip-protocol/types");
 
 // src/index.ts
-var import_types42 = require("@sip-protocol/types");
-
-// 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_chacha2 = require("@noble/ciphers/chacha.js");
-var import_hkdf2 = require("@noble/hashes/hkdf");
+var import_types60 = require("@sip-protocol/types");
 
-// src/payment/stablecoins.ts
-var STABLECOIN_INFO = {
-  USDC: {
-    symbol: "USDC",
-    name: "USD Coin",
-    issuer: "Circle",
-    type: "fiat-backed",
-    description: "Fully-reserved US dollar stablecoin by Circle"
-  },
-  USDT: {
-    symbol: "USDT",
-    name: "Tether USD",
-    issuer: "Tether",
-    type: "fiat-backed",
-    description: "Largest stablecoin by market cap"
-  },
-  DAI: {
-    symbol: "DAI",
+// 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_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");
+
+// src/payment/stablecoins.ts
+var STABLECOIN_INFO = {
+  USDC: {
+    symbol: "USDC",
+    name: "USD Coin",
+    issuer: "Circle",
+    type: "fiat-backed",
+    description: "Fully-reserved US dollar stablecoin by Circle"
+  },
+  USDT: {
+    symbol: "USDT",
+    name: "Tether USD",
+    issuer: "Tether",
+    type: "fiat-backed",
+    description: "Largest stablecoin by market cap"
+  },
+  DAI: {
+    symbol: "DAI",
     name: "Dai Stablecoin",
     issuer: "MakerDAO",
     type: "crypto-backed",
@@ -6882,8 +7721,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,
@@ -6923,7 +7762,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,
@@ -6950,17 +7789,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);
@@ -6968,11 +7807,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);
@@ -7020,9 +7859,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;
@@ -7513,12 +8352,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({
@@ -7530,13 +8369,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);
@@ -7546,9 +8385,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;
   }
@@ -7706,7 +8545,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,
@@ -8127,6 +8966,79 @@ var ComplianceManager = class _ComplianceManager {
   getAllReports() {
     return Array.from(this.reports.values());
   }
+  // ─── Dashboard Data API ──────────────────────────────────────────────────────
+  /**
+   * Get list of auditors for dashboard UI
+   *
+   * Returns a simplified view of auditors with essential info.
+   * Alias for getAllAuditors() but returns AuditorRegistration directly.
+   *
+   * @returns Array of auditor registrations
+   */
+  getAuditorList() {
+    return this.getAllAuditors();
+  }
+  /**
+   * Get pending disclosure requests for dashboard
+   *
+   * Returns disclosure requests waiting for approval/denial.
+   * This is for disclosure REQUESTS, not disclosed transactions.
+   *
+   * @returns Array of pending disclosure requests
+   */
+  getPendingDisclosures() {
+    return this.getPendingRequests();
+  }
+  /**
+   * Get disclosure history for a specific auditor
+   *
+   * Returns all disclosed transactions that were shared with this auditor,
+   * sorted by disclosure date (most recent first).
+   *
+   * @param auditorId - Auditor ID to get history for
+   * @returns Array of disclosed transactions for this auditor
+   */
+  getDisclosureHistory(auditorId) {
+    return this.getDisclosedTransactions(auditorId).sort((a, b) => b.disclosedAt - a.disclosedAt);
+  }
+  /**
+   * Get compliance metrics for dashboard
+   *
+   * Calculates key compliance metrics including:
+   * - Total auditors (active + inactive)
+   * - Total disclosures made
+   * - Pending disclosure requests
+   * - Approval rate (approved / total resolved requests)
+   * - Average processing time for disclosure requests
+   *
+   * @returns Compliance metrics object
+   */
+  getComplianceMetrics() {
+    const allAuditors = this.getAllAuditors();
+    const allDisclosures = this.getDisclosedTransactions();
+    const pendingRequests = this.getPendingRequests();
+    const allRequests = Array.from(this.disclosureRequests.values());
+    const resolvedRequests = allRequests.filter((r) => r.status !== "pending");
+    const approvedRequests = resolvedRequests.filter((r) => r.status === "approved");
+    const approvalRate = resolvedRequests.length > 0 ? approvedRequests.length / resolvedRequests.length : 0;
+    let averageProcessingTime;
+    if (resolvedRequests.length > 0) {
+      const totalProcessingTime = resolvedRequests.reduce((sum, req) => {
+        if (req.resolvedAt) {
+          return sum + (req.resolvedAt - req.requestedAt);
+        }
+        return sum;
+      }, 0);
+      averageProcessingTime = totalProcessingTime / resolvedRequests.length;
+    }
+    return {
+      totalAuditors: allAuditors.length,
+      totalDisclosures: allDisclosures.length,
+      pendingDisclosures: pendingRequests.length,
+      approvalRate,
+      averageProcessingTime
+    };
+  }
   // ─── Audit Log ───────────────────────────────────────────────────────────────
   /**
    * Get audit log entries
@@ -8325,147 +9237,1767 @@ var ComplianceManager = class _ComplianceManager {
         highRisk,
         flaggedTransactions: flagged
       }
-    };
-    if (includeTransactions) {
-      data.transactions = transactions;
+    };
+    if (includeTransactions) {
+      data.transactions = transactions;
+    }
+    return data;
+  }
+  generateCSV(transactions) {
+    const headers = [
+      "Transaction ID",
+      "Disclosure ID",
+      "Type",
+      "Direction",
+      "Token",
+      "Amount",
+      "Sender",
+      "Recipient",
+      "Chain",
+      "Privacy Level",
+      "Timestamp",
+      "TX Hash",
+      "Block",
+      "Risk Score",
+      "Purpose",
+      "Memo"
+    ];
+    const rows = transactions.map((tx) => [
+      tx.transactionId,
+      tx.disclosureId,
+      tx.type,
+      tx.direction,
+      tx.token.symbol,
+      tx.amount.toString(),
+      tx.sender,
+      tx.recipient,
+      tx.chain,
+      tx.privacyLevel,
+      new Date(tx.timestamp * 1e3).toISOString(),
+      tx.txHash,
+      tx.blockNumber.toString(),
+      tx.riskScore?.toString() ?? "",
+      tx.purpose ?? "",
+      tx.memo ?? ""
+    ]);
+    const escapeForCSV = (val) => {
+      let escaped = val;
+      if (/^[=+\-@|\t]/.test(escaped)) {
+        escaped = `'${escaped}`;
+      }
+      return `"${escaped.replace(/"/g, '""')}"`;
+    };
+    const csvRows = [headers, ...rows].map((row) => row.map(escapeForCSV).join(","));
+    return csvRows.join("\n");
+  }
+};
+function generateId(prefix) {
+  return `${prefix}_${(0, import_utils20.bytesToHex)((0, import_utils20.randomBytes)(12))}`;
+}
+function validateRegisterAuditorParams(params) {
+  if (!params.organization?.trim()) {
+    throw new ValidationError(
+      "organization is required",
+      "organization",
+      void 0,
+      "SIP_2008" /* MISSING_REQUIRED */
+    );
+  }
+  if (!params.contactName?.trim()) {
+    throw new ValidationError(
+      "contact name is required",
+      "contactName",
+      void 0,
+      "SIP_2008" /* MISSING_REQUIRED */
+    );
+  }
+  if (!params.contactEmail?.trim()) {
+    throw new ValidationError(
+      "contact email is required",
+      "contactEmail",
+      void 0,
+      "SIP_2008" /* MISSING_REQUIRED */
+    );
+  }
+  if (!params.publicKey?.trim()) {
+    throw new ValidationError(
+      "public key is required",
+      "publicKey",
+      void 0,
+      "SIP_2008" /* MISSING_REQUIRED */
+    );
+  }
+  if (!params.scope) {
+    throw new ValidationError(
+      "audit scope is required",
+      "scope",
+      void 0,
+      "SIP_2008" /* MISSING_REQUIRED */
+    );
+  }
+}
+function validateReportParams(params) {
+  if (!params.title?.trim()) {
+    throw new ValidationError(
+      "report title is required",
+      "title",
+      void 0,
+      "SIP_2008" /* MISSING_REQUIRED */
+    );
+  }
+  if (!params.type) {
+    throw new ValidationError(
+      "report type is required",
+      "type",
+      void 0,
+      "SIP_2008" /* MISSING_REQUIRED */
+    );
+  }
+  if (!params.format) {
+    throw new ValidationError(
+      "report format is required",
+      "format",
+      void 0,
+      "SIP_2008" /* MISSING_REQUIRED */
+    );
+  }
+  if (params.startDate === void 0 || params.startDate === null || params.endDate === void 0 || params.endDate === null) {
+    throw new ValidationError(
+      "date range is required",
+      "dateRange",
+      void 0,
+      "SIP_2008" /* MISSING_REQUIRED */
+    );
+  }
+  if (params.startDate >= params.endDate) {
+    throw new ValidationError(
+      "start date must be before end date",
+      "dateRange",
+      void 0,
+      "SIP_2001" /* INVALID_INPUT */
+    );
+  }
+}
+
+// src/compliance/reports.ts
+var import_sha25615 = require("@noble/hashes/sha256");
+var import_utils21 = require("@noble/hashes/utils");
+
+// src/compliance/pdf.ts
+function generatePdfReport(report, options = {}) {
+  const {
+    title = "SIP Protocol Audit Report",
+    organization = "",
+    includeTransactions = true,
+    maxTransactions = 100
+  } = options;
+  const content = buildPdfContent(report, {
+    title,
+    organization,
+    includeTransactions,
+    maxTransactions
+  });
+  return generatePdfBinary(content, title);
+}
+function buildPdfContent(report, options) {
+  const lines = [];
+  lines.push(options.title);
+  if (options.organization && options.organization.trim() !== "") {
+    lines.push(`Organization: ${options.organization}`);
+  }
+  lines.push(`Report ID: ${report.reportId}`);
+  lines.push(
+    `Generated: ${report.generatedAt.toISOString().replace("T", " ").slice(0, 19)} UTC`
+  );
+  lines.push("");
+  lines.push("Report Period");
+  lines.push(`  Start: ${formatDate(report.period.start)}`);
+  lines.push(`  End:   ${formatDate(report.period.end)}`);
+  lines.push("");
+  lines.push("Summary Statistics");
+  lines.push(`  Total Transactions: ${report.summary.transactionCount}`);
+  lines.push(
+    `  Total Volume: ${formatBigInt(report.summary.totalVolume)}`
+  );
+  lines.push(
+    `  Unique Counterparties: ${report.summary.uniqueCounterparties}`
+  );
+  lines.push("");
+  if (options.includeTransactions && report.transactions.length > 0) {
+    lines.push("Transaction Details");
+    lines.push("");
+    const txToShow = Math.min(
+      report.transactions.length,
+      options.maxTransactions
+    );
+    for (let i = 0; i < txToShow; i++) {
+      const tx = report.transactions[i];
+      lines.push(`Transaction ${i + 1}/${report.transactions.length}`);
+      lines.push(`  ID: ${tx.id}`);
+      lines.push(`  Sender: ${truncateAddress(tx.sender)}`);
+      lines.push(`  Recipient: ${truncateAddress(tx.recipient)}`);
+      lines.push(`  Amount: ${formatAmount(tx.amount)}`);
+      lines.push(
+        `  Timestamp: ${formatTimestamp(tx.timestamp)}`
+      );
+      if (tx.txHash) {
+        lines.push(`  Tx Hash: ${truncateHash(tx.txHash)}`);
+      }
+      if (tx.metadata && Object.keys(tx.metadata).length > 0) {
+        lines.push(`  Metadata: ${JSON.stringify(tx.metadata)}`);
+      }
+      lines.push("");
+    }
+    if (report.transactions.length > options.maxTransactions) {
+      lines.push(
+        `... and ${report.transactions.length - options.maxTransactions} more transactions`
+      );
+      lines.push("");
+    }
+  }
+  lines.push("---");
+  lines.push(
+    "This report was generated by SIP Protocol compliance tools."
+  );
+  lines.push("For verification, please contact your compliance officer.");
+  return lines.join("\n");
+}
+function generatePdfBinary(content, title) {
+  const objects = [];
+  objects.push(
+    "1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj"
+  );
+  objects.push(
+    "2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj"
+  );
+  objects.push(
+    "3 0 obj\n<< /Type /Page /Parent 2 0 R /Resources 4 0 R /MediaBox [0 0 612 792] /Contents 5 0 R >>\nendobj"
+  );
+  objects.push(
+    "4 0 obj\n<< /Font << /F1 << /Type /Font /Subtype /Type1 /BaseFont /Courier >> >> >>\nendobj"
+  );
+  const contentStream = buildContentStream(content);
+  objects.push(
+    `5 0 obj
+<< /Length ${contentStream.length} >>
+stream
+${contentStream}
+endstream
+endobj`
+  );
+  const now = /* @__PURE__ */ new Date();
+  const pdfDate = formatPdfDate(now);
+  objects.push(
+    `6 0 obj
+<< /Title (${title}) /Author (SIP Protocol) /Creator (SIP SDK) /CreationDate (${pdfDate}) >>
+endobj`
+  );
+  const pdfParts = [];
+  pdfParts.push("%PDF-1.4\n%\xE2\xE3\xCF\xD3\n");
+  const xrefOffsets = [0];
+  let currentOffset = pdfParts.join("").length;
+  for (const obj of objects) {
+    xrefOffsets.push(currentOffset);
+    pdfParts.push(obj + "\n");
+    currentOffset = pdfParts.join("").length;
+  }
+  const xrefStart = currentOffset;
+  pdfParts.push("xref\n");
+  pdfParts.push(`0 ${xrefOffsets.length}
+`);
+  for (let i = 0; i < xrefOffsets.length; i++) {
+    if (i === 0) {
+      pdfParts.push("0000000000 65535 f \n");
+    } else {
+      const offset = String(xrefOffsets[i]).padStart(10, "0");
+      pdfParts.push(`${offset} 00000 n 
+`);
+    }
+  }
+  pdfParts.push("trailer\n");
+  pdfParts.push(
+    `<< /Size ${xrefOffsets.length} /Root 1 0 R /Info 6 0 R >>
+`
+  );
+  pdfParts.push("startxref\n");
+  pdfParts.push(`${xrefStart}
+`);
+  pdfParts.push("%%EOF");
+  const pdfString = pdfParts.join("");
+  const encoder = new TextEncoder();
+  return encoder.encode(pdfString);
+}
+function buildContentStream(text) {
+  const lines = text.split("\n");
+  const commands = [];
+  commands.push("BT");
+  commands.push("/F1 10 Tf");
+  commands.push("12 TL");
+  let y = 742;
+  for (const line of lines) {
+    commands.push(`50 ${y} Td`);
+    const escaped = escapePdfString(line);
+    commands.push(`(${escaped}) Tj`);
+    y -= 12;
+    if (y < 50) {
+      break;
+    }
+  }
+  commands.push("ET");
+  return commands.join("\n");
+}
+function escapePdfString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)").replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+}
+function formatPdfDate(date) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  const hour = String(date.getUTCHours()).padStart(2, "0");
+  const minute = String(date.getUTCMinutes()).padStart(2, "0");
+  const second = String(date.getUTCSeconds()).padStart(2, "0");
+  return `D:${year}${month}${day}${hour}${minute}${second}Z`;
+}
+function formatDate(date) {
+  return date.toISOString().split("T")[0];
+}
+function formatBigInt(value) {
+  return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+function formatAmount(amount) {
+  try {
+    const num = BigInt(amount);
+    return formatBigInt(num);
+  } catch {
+    return amount;
+  }
+}
+function formatTimestamp(timestamp) {
+  const date = new Date(timestamp * 1e3);
+  return date.toISOString().replace("T", " ").slice(0, 19) + " UTC";
+}
+function truncateAddress(address) {
+  if (address.length <= 12) {
+    return address;
+  }
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function truncateHash(hash2) {
+  if (hash2.length <= 16) {
+    return hash2;
+  }
+  return `${hash2.slice(0, 8)}...${hash2.slice(-8)}`;
+}
+
+// src/compliance/reports.ts
+var ComplianceReporter = class {
+  /**
+   * Generate an audit report from encrypted transactions
+   *
+   * Decrypts transactions using the provided viewing key, filters by date range,
+   * and generates a comprehensive report with summary statistics.
+   *
+   * @param params - Report generation parameters
+   * @returns Audit report with decrypted transactions and statistics
+   * @throws {ValidationError} If parameters are invalid
+   * @throws {CryptoError} If decryption fails
+   */
+  async generateAuditReport(params) {
+    this.validateParams(params);
+    const viewingKey = this.normalizeViewingKey(params.viewingKey);
+    const decryptedTransactions = this.decryptTransactions(
+      params.transactions,
+      viewingKey,
+      params.startDate,
+      params.endDate
+    );
+    const summary = this.calculateSummary(decryptedTransactions);
+    const period = this.determinePeriod(
+      decryptedTransactions,
+      params.startDate,
+      params.endDate
+    );
+    const reportId = `audit_${generateRandomBytes(16).slice(2)}`;
+    return {
+      reportId,
+      generatedAt: /* @__PURE__ */ new Date(),
+      period,
+      transactions: decryptedTransactions,
+      summary
+    };
+  }
+  /**
+   * Validate report generation parameters
+   */
+  validateParams(params) {
+    if (!params.viewingKey) {
+      throw new ValidationError(
+        "viewingKey is required",
+        "viewingKey",
+        void 0,
+        "SIP_2008" /* MISSING_REQUIRED */
+      );
+    }
+    if (!params.transactions) {
+      throw new ValidationError(
+        "transactions array is required",
+        "transactions",
+        void 0,
+        "SIP_2008" /* MISSING_REQUIRED */
+      );
+    }
+    if (!Array.isArray(params.transactions)) {
+      throw new ValidationError(
+        "transactions must be an array",
+        "transactions",
+        { received: typeof params.transactions },
+        "SIP_2001" /* INVALID_INPUT */
+      );
+    }
+    if (params.format !== "json" && params.format !== "pdf") {
+      throw new ValidationError(
+        "only JSON and PDF formats are supported",
+        "format",
+        { received: params.format },
+        "SIP_2001" /* INVALID_INPUT */
+      );
+    }
+    if (params.startDate && params.endDate) {
+      if (params.startDate > params.endDate) {
+        throw new ValidationError(
+          "startDate must be before endDate",
+          "startDate",
+          {
+            startDate: params.startDate.toISOString(),
+            endDate: params.endDate.toISOString()
+          },
+          "SIP_2001" /* INVALID_INPUT */
+        );
+      }
+    }
+  }
+  /**
+   * Normalize viewing key to ViewingKey object
+   */
+  normalizeViewingKey(viewingKey) {
+    if (typeof viewingKey === "string") {
+      const keyHex = viewingKey.startsWith("0x") ? viewingKey.slice(2) : viewingKey;
+      const keyBytes = (0, import_utils21.hexToBytes)(keyHex);
+      const hashBytes = (0, import_sha25615.sha256)(keyBytes);
+      return {
+        key: `0x${keyHex}`,
+        path: "m/0",
+        hash: `0x${(0, import_utils21.bytesToHex)(hashBytes)}`
+      };
+    }
+    return viewingKey;
+  }
+  /**
+   * Decrypt transactions and filter by date range
+   */
+  decryptTransactions(encrypted, viewingKey, startDate, endDate) {
+    const decrypted = [];
+    const errors = [];
+    for (let i = 0; i < encrypted.length; i++) {
+      try {
+        const txData = decryptWithViewing(encrypted[i], viewingKey);
+        if (startDate || endDate) {
+          const txDate = new Date(txData.timestamp * 1e3);
+          if (startDate && txDate < startDate) {
+            continue;
+          }
+          if (endDate && txDate > endDate) {
+            continue;
+          }
+        }
+        decrypted.push({
+          id: `tx_${i}`,
+          sender: txData.sender,
+          recipient: txData.recipient,
+          amount: txData.amount,
+          timestamp: txData.timestamp
+        });
+      } catch (error) {
+        errors.push({ index: i, error });
+      }
+    }
+    if (decrypted.length === 0 && encrypted.length > 0) {
+      throw new CryptoError(
+        `Failed to decrypt any transactions. First error: ${errors[0]?.error.message}`,
+        "SIP_3002" /* DECRYPTION_FAILED */,
+        {
+          context: {
+            totalTransactions: encrypted.length,
+            failedCount: errors.length
+          }
+        }
+      );
+    }
+    return decrypted;
+  }
+  /**
+   * Calculate summary statistics
+   */
+  calculateSummary(transactions) {
+    let totalVolume = 0n;
+    const counterparties = /* @__PURE__ */ new Set();
+    for (const tx of transactions) {
+      try {
+        const amount = BigInt(tx.amount);
+        totalVolume += amount;
+      } catch (error) {
+        console.warn(`Skipping invalid amount in transaction ${tx.id}: ${tx.amount}`);
+      }
+      counterparties.add(tx.sender);
+      counterparties.add(tx.recipient);
+    }
+    return {
+      totalVolume,
+      transactionCount: transactions.length,
+      uniqueCounterparties: counterparties.size
+    };
+  }
+  /**
+   * Determine report period from transactions and params
+   */
+  determinePeriod(transactions, startDate, endDate) {
+    if (startDate && endDate) {
+      return { start: startDate, end: endDate };
+    }
+    if (transactions.length === 0) {
+      const now = /* @__PURE__ */ new Date();
+      return { start: now, end: now };
+    }
+    let minTimestamp = transactions[0].timestamp;
+    let maxTimestamp = transactions[0].timestamp;
+    for (const tx of transactions) {
+      if (tx.timestamp < minTimestamp) {
+        minTimestamp = tx.timestamp;
+      }
+      if (tx.timestamp > maxTimestamp) {
+        maxTimestamp = tx.timestamp;
+      }
+    }
+    return {
+      start: startDate || new Date(minTimestamp * 1e3),
+      end: endDate || new Date(maxTimestamp * 1e3)
+    };
+  }
+  /**
+   * Export audit report to PDF format
+   *
+   * Generates a professionally formatted PDF document from an audit report.
+   * Works in both Node.js and browser environments.
+   *
+   * @param report - The audit report to export
+   * @param options - PDF export options
+   * @returns PDF document as Uint8Array
+   *
+   * @example
+   * ```typescript
+   * const reporter = new ComplianceReporter()
+   * const report = await reporter.generateAuditReport({...})
+   *
+   * const pdfBytes = reporter.exportToPdf(report, {
+   *   title: 'Q1 2025 Audit Report',
+   *   organization: 'ACME Corp',
+   * })
+   *
+   * // Save to file (Node.js)
+   * fs.writeFileSync('report.pdf', pdfBytes)
+   * ```
+   */
+  exportToPdf(report, options) {
+    return generatePdfReport(report, options);
+  }
+  /**
+   * Export transactions to regulatory compliance formats
+   *
+   * Decrypts and exports transactions in formats required by regulators:
+   * - FATF: Financial Action Task Force Travel Rule format
+   * - FINCEN: FinCEN Suspicious Activity Report (SAR) format
+   * - CSV: Generic comma-separated values format
+   *
+   * @param params - Export parameters
+   * @returns Regulatory export in the specified format
+   * @throws {ValidationError} If parameters are invalid
+   * @throws {CryptoError} If decryption fails
+   *
+   * @example
+   * ```typescript
+   * const reporter = new ComplianceReporter()
+   *
+   * // FATF Travel Rule export
+   * const fatfExport = await reporter.exportForRegulator({
+   *   viewingKey: myViewingKey,
+   *   transactions: encryptedTxs,
+   *   jurisdiction: 'EU',
+   *   format: 'FATF',
+   *   currency: 'EUR',
+   * })
+   *
+   * // FINCEN SAR export (US only)
+   * const fincenExport = await reporter.exportForRegulator({
+   *   viewingKey: myViewingKey,
+   *   transactions: suspiciousTxs,
+   *   jurisdiction: 'US',
+   *   format: 'FINCEN',
+   * })
+   *
+   * // CSV export
+   * const csvExport = await reporter.exportForRegulator({
+   *   viewingKey: myViewingKey,
+   *   transactions: encryptedTxs,
+   *   jurisdiction: 'SG',
+   *   format: 'CSV',
+   * })
+   * ```
+   */
+  async exportForRegulator(params) {
+    this.validateRegulatoryParams(params);
+    const viewingKey = this.normalizeViewingKey(params.viewingKey);
+    const decryptedTransactions = this.decryptTransactions(
+      params.transactions,
+      viewingKey,
+      params.startDate,
+      params.endDate
+    );
+    const reportId = `reg_${generateRandomBytes(16).slice(2)}`;
+    switch (params.format) {
+      case "FATF":
+        return this.exportToFATF(
+          reportId,
+          decryptedTransactions,
+          params.jurisdiction,
+          params.currency || "USD"
+        );
+      case "FINCEN":
+        return this.exportToFINCEN(
+          reportId,
+          decryptedTransactions,
+          params.startDate,
+          params.endDate,
+          params.currency || "USD"
+        );
+      case "CSV":
+        return this.exportToCSV(
+          reportId,
+          decryptedTransactions,
+          params.jurisdiction,
+          params.currency || "USD"
+        );
+      default:
+        throw new ValidationError(
+          `unsupported format: ${params.format}`,
+          "format",
+          { received: params.format },
+          "SIP_2001" /* INVALID_INPUT */
+        );
+    }
+  }
+  /**
+   * Validate regulatory export parameters
+   */
+  validateRegulatoryParams(params) {
+    if (!params.viewingKey) {
+      throw new ValidationError(
+        "viewingKey is required",
+        "viewingKey",
+        void 0,
+        "SIP_2008" /* MISSING_REQUIRED */
+      );
+    }
+    if (!params.transactions) {
+      throw new ValidationError(
+        "transactions array is required",
+        "transactions",
+        void 0,
+        "SIP_2008" /* MISSING_REQUIRED */
+      );
+    }
+    if (!Array.isArray(params.transactions)) {
+      throw new ValidationError(
+        "transactions must be an array",
+        "transactions",
+        { received: typeof params.transactions },
+        "SIP_2001" /* INVALID_INPUT */
+      );
+    }
+    if (!params.jurisdiction) {
+      throw new ValidationError(
+        "jurisdiction is required",
+        "jurisdiction",
+        void 0,
+        "SIP_2008" /* MISSING_REQUIRED */
+      );
+    }
+    const validJurisdictions = ["US", "EU", "UK", "SG"];
+    if (!validJurisdictions.includes(params.jurisdiction)) {
+      throw new ValidationError(
+        `invalid jurisdiction. Must be one of: ${validJurisdictions.join(", ")}`,
+        "jurisdiction",
+        { received: params.jurisdiction },
+        "SIP_2001" /* INVALID_INPUT */
+      );
+    }
+    if (!params.format) {
+      throw new ValidationError(
+        "format is required",
+        "format",
+        void 0,
+        "SIP_2008" /* MISSING_REQUIRED */
+      );
+    }
+    const validFormats = ["FATF", "FINCEN", "CSV"];
+    if (!validFormats.includes(params.format)) {
+      throw new ValidationError(
+        `invalid format. Must be one of: ${validFormats.join(", ")}`,
+        "format",
+        { received: params.format },
+        "SIP_2001" /* INVALID_INPUT */
+      );
+    }
+    if (params.format === "FINCEN" && params.jurisdiction !== "US") {
+      throw new ValidationError(
+        "FINCEN format is only available for US jurisdiction",
+        "format",
+        { jurisdiction: params.jurisdiction, format: params.format },
+        "SIP_2001" /* INVALID_INPUT */
+      );
+    }
+    if (params.startDate && params.endDate) {
+      if (params.startDate > params.endDate) {
+        throw new ValidationError(
+          "startDate must be before endDate",
+          "startDate",
+          {
+            startDate: params.startDate.toISOString(),
+            endDate: params.endDate.toISOString()
+          },
+          "SIP_2001" /* INVALID_INPUT */
+        );
+      }
+    }
+  }
+  /**
+   * Export to FATF Travel Rule format
+   */
+  exportToFATF(reportId, transactions, jurisdiction, currency) {
+    const fatfTransactions = transactions.map((tx) => ({
+      originatorAccount: tx.sender,
+      beneficiaryAccount: tx.recipient,
+      amount: tx.amount,
+      currency,
+      transactionRef: tx.id,
+      timestamp: new Date(tx.timestamp * 1e3).toISOString()
+    }));
+    return {
+      reportId,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      jurisdiction,
+      transactions: fatfTransactions
+    };
+  }
+  /**
+   * Export to FINCEN SAR format
+   */
+  exportToFINCEN(reportId, transactions, startDate, endDate, currency = "USD") {
+    let totalAmount = 0n;
+    for (const tx of transactions) {
+      try {
+        totalAmount += BigInt(tx.amount);
+      } catch (error) {
+      }
+    }
+    const period = this.determinePeriod(transactions, startDate, endDate);
+    const fincenTransactions = transactions.map((tx) => ({
+      transactionDate: new Date(tx.timestamp * 1e3).toISOString(),
+      amount: tx.amount,
+      currency,
+      narrativeSummary: `Transfer from ${tx.sender} to ${tx.recipient}`,
+      transactionRef: tx.id,
+      parties: {
+        sender: tx.sender,
+        recipient: tx.recipient
+      }
+    }));
+    return {
+      reportId,
+      filingType: "SAR",
+      reportDate: (/* @__PURE__ */ new Date()).toISOString(),
+      jurisdiction: "US",
+      summary: {
+        transactionCount: transactions.length,
+        totalAmount: totalAmount.toString(),
+        period: {
+          start: period.start.toISOString(),
+          end: period.end.toISOString()
+        }
+      },
+      transactions: fincenTransactions
+    };
+  }
+  /**
+   * Export to CSV format
+   */
+  exportToCSV(reportId, transactions, jurisdiction, currency) {
+    const headers = [
+      "Transaction ID",
+      "Timestamp",
+      "Sender",
+      "Recipient",
+      "Amount",
+      "Currency"
+    ];
+    const rows = transactions.map((tx) => [
+      tx.id,
+      new Date(tx.timestamp * 1e3).toISOString(),
+      tx.sender,
+      tx.recipient,
+      tx.amount,
+      currency
+    ]);
+    return {
+      reportId,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      jurisdiction,
+      headers,
+      rows
+    };
+  }
+};
+
+// src/compliance/conditional.ts
+var import_sha25616 = require("@noble/hashes/sha256");
+var import_utils22 = require("@noble/hashes/utils");
+var import_chacha3 = require("@noble/ciphers/chacha.js");
+var ConditionalDisclosure = class {
+  /**
+   * Create a time-locked disclosure
+   *
+   * Encrypts the viewing key with a deterministic key derived from
+   * the commitment and reveal time. The key can only be reconstructed
+   * after the specified time/block height.
+   *
+   * @param params - Time-lock parameters
+   * @returns Time-lock result with encrypted key
+   * @throws {ValidationError} If parameters are invalid
+   * @throws {CryptoError} If encryption fails
+   */
+  createTimeLocked(params) {
+    if (!params.viewingKey || !params.viewingKey.startsWith("0x")) {
+      throw new ValidationError(
+        "Invalid viewing key format",
+        "viewingKey",
+        { viewingKey: params.viewingKey },
+        "SIP_2006" /* INVALID_KEY */
+      );
+    }
+    if (!params.commitment || !params.commitment.startsWith("0x")) {
+      throw new ValidationError(
+        "Invalid commitment format",
+        "commitment",
+        { commitment: params.commitment },
+        "SIP_3010" /* INVALID_COMMITMENT */
+      );
+    }
+    let revealAfterSeconds;
+    let type;
+    if (params.revealAfter instanceof Date) {
+      revealAfterSeconds = Math.floor(params.revealAfter.getTime() / 1e3);
+      type = "timestamp";
+    } else if (typeof params.revealAfter === "number") {
+      if (params.revealAfter > 1e10) {
+        revealAfterSeconds = Math.floor(params.revealAfter / 1e3);
+        type = "timestamp";
+      } else {
+        revealAfterSeconds = params.revealAfter;
+        type = "blockheight";
+      }
+      if (revealAfterSeconds <= 0) {
+        throw new ValidationError(
+          "Reveal time/block height must be positive",
+          "revealAfter",
+          { revealAfter: revealAfterSeconds },
+          "SIP_3011" /* INVALID_TIME_LOCK */
+        );
+      }
+    } else {
+      throw new ValidationError(
+        "Invalid revealAfter type (must be Date or number)",
+        "revealAfter",
+        { revealAfter: params.revealAfter },
+        "SIP_3011" /* INVALID_TIME_LOCK */
+      );
+    }
+    try {
+      const encryptionKey = this._deriveEncryptionKey(
+        params.commitment,
+        revealAfterSeconds
+      );
+      const nonce = (0, import_utils22.randomBytes)(24);
+      const viewingKeyBytes = (0, import_utils22.hexToBytes)(params.viewingKey.slice(2));
+      const cipher = (0, import_chacha3.xchacha20poly1305)(encryptionKey, nonce);
+      const encryptedKey = cipher.encrypt(viewingKeyBytes);
+      const commitmentData = new Uint8Array([
+        ...viewingKeyBytes,
+        ...this._numberToBytes(revealAfterSeconds)
+      ]);
+      const commitmentHash = (0, import_sha25616.sha256)(commitmentData);
+      return {
+        encryptedKey: "0x" + (0, import_utils22.bytesToHex)(encryptedKey),
+        nonce: "0x" + (0, import_utils22.bytesToHex)(nonce),
+        revealAfter: revealAfterSeconds,
+        verificationCommitment: "0x" + (0, import_utils22.bytesToHex)(commitmentHash),
+        encryptionCommitment: params.commitment,
+        type
+      };
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        throw error;
+      }
+      throw new CryptoError(
+        "Failed to create time-locked disclosure",
+        "SIP_3001" /* ENCRYPTION_FAILED */,
+        {
+          cause: error instanceof Error ? error : void 0,
+          operation: "createTimeLocked"
+        }
+      );
+    }
+  }
+  /**
+   * Check if a time-lock is unlocked and retrieve the viewing key
+   *
+   * @param timeLock - Time-lock result to check
+   * @param currentTimeOrBlock - Current time (Date/number) or block height (number)
+   * @returns Unlock result with viewing key if unlocked
+   * @throws {ValidationError} If time-lock format is invalid
+   * @throws {CryptoError} If decryption fails
+   */
+  checkUnlocked(timeLock, currentTimeOrBlock) {
+    if (!timeLock.encryptedKey || !timeLock.encryptedKey.startsWith("0x")) {
+      throw new ValidationError(
+        "Invalid encrypted key format",
+        "encryptedKey",
+        { encryptedKey: timeLock.encryptedKey },
+        "SIP_3009" /* INVALID_ENCRYPTED_DATA */
+      );
+    }
+    if (!timeLock.nonce || !timeLock.nonce.startsWith("0x")) {
+      throw new ValidationError(
+        "Invalid nonce format",
+        "nonce",
+        { nonce: timeLock.nonce },
+        "SIP_3009" /* INVALID_ENCRYPTED_DATA */
+      );
+    }
+    if (!timeLock.verificationCommitment || !timeLock.verificationCommitment.startsWith("0x")) {
+      throw new ValidationError(
+        "Invalid verification commitment format",
+        "verificationCommitment",
+        { commitment: timeLock.verificationCommitment },
+        "SIP_3010" /* INVALID_COMMITMENT */
+      );
+    }
+    if (!timeLock.encryptionCommitment || !timeLock.encryptionCommitment.startsWith("0x")) {
+      throw new ValidationError(
+        "Invalid encryption commitment format",
+        "encryptionCommitment",
+        { commitment: timeLock.encryptionCommitment },
+        "SIP_3010" /* INVALID_COMMITMENT */
+      );
+    }
+    let currentValue;
+    if (currentTimeOrBlock instanceof Date) {
+      currentValue = Math.floor(currentTimeOrBlock.getTime() / 1e3);
+    } else if (typeof currentTimeOrBlock === "number") {
+      currentValue = currentTimeOrBlock;
+    } else {
+      currentValue = Math.floor(Date.now() / 1e3);
+    }
+    const unlocked = currentValue >= timeLock.revealAfter;
+    if (!unlocked) {
+      return { unlocked: false };
+    }
+    try {
+      const encryptionKey = this._deriveEncryptionKey(
+        timeLock.encryptionCommitment,
+        timeLock.revealAfter
+      );
+      const nonce = (0, import_utils22.hexToBytes)(timeLock.nonce.slice(2));
+      const encryptedData = (0, import_utils22.hexToBytes)(timeLock.encryptedKey.slice(2));
+      const cipher = (0, import_chacha3.xchacha20poly1305)(encryptionKey, nonce);
+      const decryptedBytes = cipher.decrypt(encryptedData);
+      const viewingKey = "0x" + (0, import_utils22.bytesToHex)(decryptedBytes);
+      return {
+        unlocked: true,
+        viewingKey
+      };
+    } catch (error) {
+      if (error instanceof ValidationError || error instanceof CryptoError) {
+        throw error;
+      }
+      throw new CryptoError(
+        "Failed to decrypt time-locked viewing key",
+        "SIP_3002" /* DECRYPTION_FAILED */,
+        {
+          cause: error instanceof Error ? error : void 0,
+          operation: "checkUnlocked"
+        }
+      );
+    }
+  }
+  /**
+   * Verify a time-lock commitment
+   *
+   * Verifies that the verification commitment in the time-lock matches the hash
+   * of the provided viewing key and reveal time.
+   *
+   * @param timeLock - Time-lock to verify
+   * @param viewingKey - Viewing key to verify against
+   * @returns True if commitment is valid
+   */
+  verifyCommitment(timeLock, viewingKey) {
+    try {
+      const viewingKeyBytes = (0, import_utils22.hexToBytes)(viewingKey.slice(2));
+      const commitmentData = new Uint8Array([
+        ...viewingKeyBytes,
+        ...this._numberToBytes(timeLock.revealAfter)
+      ]);
+      const expectedCommitment = (0, import_sha25616.sha256)(commitmentData);
+      const actualCommitment = (0, import_utils22.hexToBytes)(timeLock.verificationCommitment.slice(2));
+      if (expectedCommitment.length !== actualCommitment.length) {
+        return false;
+      }
+      let diff = 0;
+      for (let i = 0; i < expectedCommitment.length; i++) {
+        diff |= expectedCommitment[i] ^ actualCommitment[i];
+      }
+      return diff === 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Derive deterministic encryption key from commitment and reveal time
+   *
+   * @private
+   */
+  _deriveEncryptionKey(commitment, revealAfter) {
+    const commitmentBytes = (0, import_utils22.hexToBytes)(commitment.slice(2));
+    const timeBytes = this._numberToBytes(revealAfter);
+    const combined = new Uint8Array([...commitmentBytes, ...timeBytes]);
+    const key = (0, import_sha25616.sha256)(combined);
+    if (key.length !== 32) {
+      throw new CryptoError(
+        "Derived key must be 32 bytes",
+        "SIP_3008" /* INVALID_KEY_SIZE */,
+        {
+          context: { actualSize: key.length, expectedSize: 32 },
+          operation: "_deriveEncryptionKey"
+        }
+      );
+    }
+    return key;
+  }
+  /**
+   * Convert number to 8-byte big-endian representation
+   *
+   * @private
+   */
+  _numberToBytes(num) {
+    const bytes = new Uint8Array(8);
+    const view = new DataView(bytes.buffer);
+    view.setBigUint64(0, BigInt(Math.floor(num)), false);
+    return bytes;
+  }
+};
+
+// src/compliance/conditional-threshold.ts
+var import_secp256k17 = require("@noble/curves/secp256k1");
+var import_sha25617 = require("@noble/hashes/sha256");
+var import_utils23 = require("@noble/hashes/utils");
+var CURVE_ORDER2 = import_secp256k17.secp256k1.CURVE.n;
+
+// src/compliance/threshold.ts
+var import_sha25618 = require("@noble/hashes/sha256");
+var import_utils24 = require("@noble/hashes/utils");
+var FIELD_PRIME = 2n ** 256n - 189n;
+var ThresholdViewingKey = class {
+  /**
+   * Create threshold shares from a viewing key
+   *
+   * @param params - Configuration parameters
+   * @returns Threshold shares with commitment
+   * @throws ValidationError if parameters are invalid
+   *
+   * @example
+   * ```typescript
+   * const threshold = ThresholdViewingKey.create({
+   *   threshold: 3,
+   *   totalShares: 5,
+   *   viewingKey: '0xabc123...',
+   * })
+   * ```
+   */
+  static create(params) {
+    this.validateParams(params.threshold, params.totalShares);
+    this.validateViewingKey(params.viewingKey);
+    const secret = this.viewingKeyToSecret(params.viewingKey);
+    const keyLength = params.viewingKey.slice(2).length;
+    const coefficients = this.generateCoefficients(params.threshold, secret);
+    const commitment = this.createCommitment(secret, coefficients);
+    const shares = [];
+    for (let i = 1; i <= params.totalShares; i++) {
+      const x = BigInt(i);
+      const y = this.evaluatePolynomial(coefficients, x);
+      shares.push(this.encodeShare(x, y, keyLength, commitment));
+    }
+    return {
+      shares,
+      commitment,
+      threshold: params.threshold,
+      totalShares: params.totalShares
+    };
+  }
+  /**
+   * Reconstruct viewing key from threshold shares
+   *
+   * @param shares - Array of encoded shares (must be >= threshold)
+   * @returns Reconstructed viewing key
+   * @throws ValidationError if insufficient or invalid shares
+   *
+   * @example
+   * ```typescript
+   * const viewingKey = ThresholdViewingKey.reconstruct([
+   *   'share1',
+   *   'share2',
+   *   'share3',
+   * ])
+   * ```
+   */
+  static reconstruct(shares) {
+    if (!shares || shares.length === 0) {
+      throw new ValidationError(
+        "at least one share is required",
+        "shares",
+        { received: shares },
+        "SIP_2008" /* MISSING_REQUIRED */
+      );
+    }
+    const decodedShares = shares.map((s) => this.decodeShare(s));
+    const commitment = decodedShares[0].commitment;
+    const keyLength = decodedShares[0].keyLength;
+    for (const share of decodedShares) {
+      if (share.commitment !== commitment) {
+        throw new ValidationError(
+          "shares must all have the same commitment",
+          "shares",
+          { commitment },
+          "SIP_3012" /* INVALID_SHARE */
+        );
+      }
+      if (share.keyLength !== keyLength) {
+        throw new ValidationError(
+          "shares must all have the same key length",
+          "shares",
+          { keyLength },
+          "SIP_3012" /* INVALID_SHARE */
+        );
+      }
+    }
+    const xCoords = new Set(decodedShares.map((s) => s.x.toString()));
+    if (xCoords.size !== decodedShares.length) {
+      throw new ValidationError(
+        "shares must have unique x-coordinates",
+        "shares",
+        void 0,
+        "SIP_3012" /* INVALID_SHARE */
+      );
+    }
+    const secret = this.lagrangeInterpolate(decodedShares);
+    return this.secretToViewingKey(secret, keyLength);
+  }
+  /**
+   * Verify a share without revealing the viewing key
+   *
+   * @param share - Encoded share to verify
+   * @param expectedCommitment - Expected commitment hash
+   * @returns True if share is valid
+   *
+   * @example
+   * ```typescript
+   * const isValid = ThresholdViewingKey.verifyShare(
+   *   'share1',
+   *   'commitment_hash'
+   * )
+   * ```
+   */
+  static verifyShare(share, expectedCommitment) {
+    try {
+      const decoded = this.decodeShare(share);
+      return decoded.commitment === expectedCommitment;
+    } catch {
+      return false;
+    }
+  }
+  // ─── Private Helper Methods ─────────────────────────────────────────────────
+  /**
+   * Validate threshold and total shares parameters
+   */
+  static validateParams(threshold, totalShares) {
+    if (!Number.isInteger(threshold) || threshold < 2) {
+      throw new ValidationError(
+        "threshold must be an integer >= 2",
+        "threshold",
+        { received: threshold },
+        "SIP_3013" /* INVALID_THRESHOLD */
+      );
+    }
+    if (!Number.isInteger(totalShares) || totalShares < threshold) {
+      throw new ValidationError(
+        "totalShares must be an integer >= threshold",
+        "totalShares",
+        { received: totalShares, threshold },
+        "SIP_3013" /* INVALID_THRESHOLD */
+      );
+    }
+    if (totalShares > 255) {
+      throw new ValidationError(
+        "totalShares must be <= 255",
+        "totalShares",
+        { received: totalShares },
+        "SIP_3013" /* INVALID_THRESHOLD */
+      );
+    }
+  }
+  /**
+   * Validate viewing key format
+   */
+  static validateViewingKey(viewingKey) {
+    if (!viewingKey || typeof viewingKey !== "string") {
+      throw new ValidationError(
+        "viewingKey is required",
+        "viewingKey",
+        { received: viewingKey },
+        "SIP_2008" /* MISSING_REQUIRED */
+      );
+    }
+    if (!viewingKey.startsWith("0x")) {
+      throw new ValidationError(
+        "viewingKey must be hex-encoded (start with 0x)",
+        "viewingKey",
+        { received: viewingKey },
+        "SIP_3015" /* INVALID_FORMAT */
+      );
+    }
+    if (viewingKey.length < 66) {
+      throw new ValidationError(
+        "viewingKey must be at least 32 bytes",
+        "viewingKey",
+        { received: viewingKey.length },
+        "SIP_3015" /* INVALID_FORMAT */
+      );
+    }
+  }
+  /**
+   * Convert viewing key to secret (bigint)
+   */
+  static viewingKeyToSecret(viewingKey) {
+    const bytes = (0, import_utils24.hexToBytes)(viewingKey.slice(2));
+    let secret = 0n;
+    for (let i = 0; i < bytes.length; i++) {
+      secret = secret << 8n | BigInt(bytes[i]);
+    }
+    return this.mod(secret, FIELD_PRIME);
+  }
+  /**
+   * Convert secret (bigint) back to viewing key
+   * @param secret - The secret as bigint
+   * @param hexLength - Length of the hex string (without 0x prefix)
+   */
+  static secretToViewingKey(secret, hexLength) {
+    let hex = secret.toString(16);
+    hex = hex.padStart(hexLength, "0");
+    return `0x${hex}`;
+  }
+  /**
+   * Generate random polynomial coefficients
+   * Polynomial: f(x) = a₀ + a₁x + a₂x² + ... + aₙ₋₁xⁿ⁻¹
+   * where a₀ = secret
+   */
+  static generateCoefficients(threshold, secret) {
+    const coefficients = [secret];
+    for (let i = 1; i < threshold; i++) {
+      const randomCoeff = this.randomFieldElement();
+      coefficients.push(randomCoeff);
+    }
+    return coefficients;
+  }
+  /**
+   * Generate a random field element
+   */
+  static randomFieldElement() {
+    const bytes = (0, import_utils24.randomBytes)(32);
+    let value = 0n;
+    for (let i = 0; i < bytes.length; i++) {
+      value = value << 8n | BigInt(bytes[i]);
+    }
+    return this.mod(value, FIELD_PRIME);
+  }
+  /**
+   * Evaluate polynomial at point x
+   * f(x) = a₀ + a₁x + a₂x² + ... + aₙ₋₁xⁿ⁻¹
+   */
+  static evaluatePolynomial(coefficients, x) {
+    let result = 0n;
+    let xPower = 1n;
+    for (const coeff of coefficients) {
+      result = this.mod(result + this.mod(coeff * xPower, FIELD_PRIME), FIELD_PRIME);
+      xPower = this.mod(xPower * x, FIELD_PRIME);
+    }
+    return result;
+  }
+  /**
+   * Create commitment hash from secret and coefficients
+   */
+  static createCommitment(secret, coefficients) {
+    const data = [secret, ...coefficients].map((c) => c.toString(16).padStart(64, "0")).join("");
+    const hash2 = (0, import_sha25618.sha256)((0, import_utils24.hexToBytes)(data));
+    return (0, import_utils24.bytesToHex)(hash2);
+  }
+  /**
+   * Encode share as string: "x:y:len:commitment"
+   */
+  static encodeShare(x, y, keyLength, commitment) {
+    const xHex = x.toString(16).padStart(2, "0");
+    const yHex = y.toString(16).padStart(64, "0");
+    const lenHex = keyLength.toString(16).padStart(4, "0");
+    return `${xHex}:${yHex}:${lenHex}:${commitment}`;
+  }
+  /**
+   * Decode share from string
+   */
+  static decodeShare(share) {
+    if (!share || typeof share !== "string") {
+      throw new ValidationError(
+        "share must be a non-empty string",
+        "share",
+        { received: share },
+        "SIP_3012" /* INVALID_SHARE */
+      );
+    }
+    const parts = share.split(":");
+    if (parts.length !== 4) {
+      throw new ValidationError(
+        'share must have format "x:y:len:commitment"',
+        "share",
+        { received: share },
+        "SIP_3012" /* INVALID_SHARE */
+      );
+    }
+    const [xHex, yHex, lenHex, commitment] = parts;
+    try {
+      const x = BigInt(`0x${xHex}`);
+      const y = BigInt(`0x${yHex}`);
+      const keyLength = parseInt(lenHex, 16);
+      if (x <= 0n) {
+        throw new ValidationError(
+          "share x-coordinate must be positive",
+          "share",
+          { x },
+          "SIP_3012" /* INVALID_SHARE */
+        );
+      }
+      if (keyLength < 64) {
+        throw new ValidationError(
+          "key length must be at least 64 (32 bytes)",
+          "share",
+          { keyLength },
+          "SIP_3012" /* INVALID_SHARE */
+        );
+      }
+      return { x, y, keyLength, commitment };
+    } catch (error) {
+      throw new ValidationError(
+        "failed to decode share",
+        "share",
+        { error: error.message },
+        "SIP_3012" /* INVALID_SHARE */
+      );
     }
-    return data;
   }
-  generateCSV(transactions) {
-    const headers = [
-      "Transaction ID",
-      "Disclosure ID",
-      "Type",
-      "Direction",
-      "Token",
-      "Amount",
-      "Sender",
-      "Recipient",
-      "Chain",
-      "Privacy Level",
-      "Timestamp",
-      "TX Hash",
-      "Block",
-      "Risk Score",
-      "Purpose",
-      "Memo"
-    ];
-    const rows = transactions.map((tx) => [
-      tx.transactionId,
-      tx.disclosureId,
-      tx.type,
-      tx.direction,
-      tx.token.symbol,
-      tx.amount.toString(),
-      tx.sender,
-      tx.recipient,
-      tx.chain,
-      tx.privacyLevel,
-      new Date(tx.timestamp * 1e3).toISOString(),
-      tx.txHash,
-      tx.blockNumber.toString(),
-      tx.riskScore?.toString() ?? "",
-      tx.purpose ?? "",
-      tx.memo ?? ""
-    ]);
-    const escapeForCSV = (val) => {
-      let escaped = val;
-      if (/^[=+\-@|\t]/.test(escaped)) {
-        escaped = `'${escaped}`;
+  /**
+   * Lagrange interpolation to reconstruct secret
+   * Evaluates polynomial at x=0 to get f(0) = secret
+   */
+  static lagrangeInterpolate(shares) {
+    let secret = 0n;
+    for (let i = 0; i < shares.length; i++) {
+      const xi = shares[i].x;
+      const yi = shares[i].y;
+      let numerator = 1n;
+      let denominator = 1n;
+      for (let j = 0; j < shares.length; j++) {
+        if (i === j) continue;
+        const xj = shares[j].x;
+        numerator = this.mod(numerator * this.mod(-xj, FIELD_PRIME), FIELD_PRIME);
+        denominator = this.mod(denominator * this.mod(xi - xj, FIELD_PRIME), FIELD_PRIME);
       }
-      return `"${escaped.replace(/"/g, '""')}"`;
-    };
-    const csvRows = [headers, ...rows].map((row) => row.map(escapeForCSV).join(","));
-    return csvRows.join("\n");
+      const coeff = this.mod(numerator * this.modInverse(denominator, FIELD_PRIME), FIELD_PRIME);
+      secret = this.mod(secret + this.mod(yi * coeff, FIELD_PRIME), FIELD_PRIME);
+    }
+    return secret;
   }
-};
-function generateId(prefix) {
-  return `${prefix}_${(0, import_utils14.bytesToHex)((0, import_utils14.randomBytes)(12))}`;
-}
-function validateRegisterAuditorParams(params) {
-  if (!params.organization?.trim()) {
-    throw new ValidationError(
-      "organization is required",
-      "organization",
-      void 0,
-      "SIP_2008" /* MISSING_REQUIRED */
-    );
+  /**
+   * Modular arithmetic: a mod m
+   */
+  static mod(a, m) {
+    return (a % m + m) % m;
   }
-  if (!params.contactName?.trim()) {
-    throw new ValidationError(
-      "contact name is required",
-      "contactName",
-      void 0,
-      "SIP_2008" /* MISSING_REQUIRED */
-    );
+  /**
+   * Modular multiplicative inverse using Extended Euclidean Algorithm
+   * Returns x such that (a * x) mod m = 1
+   */
+  static modInverse(a, m) {
+    const a0 = this.mod(a, m);
+    if (a0 === 0n) {
+      throw new CryptoError(
+        "modular inverse does not exist (a = 0)",
+        "SIP_3014" /* CRYPTO_OPERATION_FAILED */,
+        { operation: "modInverse" }
+      );
+    }
+    let [old_r, r] = [a0, m];
+    let [old_s, s] = [1n, 0n];
+    while (r !== 0n) {
+      const quotient = old_r / r;
+      [old_r, r] = [r, old_r - quotient * r];
+      [old_s, s] = [s, old_s - quotient * s];
+    }
+    if (old_r !== 1n) {
+      throw new CryptoError(
+        "modular inverse does not exist (gcd != 1)",
+        "SIP_3014" /* CRYPTO_OPERATION_FAILED */,
+        { operation: "modInverse" }
+      );
+    }
+    return this.mod(old_s, m);
   }
-  if (!params.contactEmail?.trim()) {
-    throw new ValidationError(
-      "contact email is required",
-      "contactEmail",
-      void 0,
-      "SIP_2008" /* MISSING_REQUIRED */
-    );
+};
+
+// src/compliance/derivation.ts
+var import_sha25619 = require("@noble/hashes/sha256");
+var import_sha5123 = require("@noble/hashes/sha512");
+var import_hmac2 = require("@noble/hashes/hmac");
+var import_utils25 = require("@noble/hashes/utils");
+var AuditorType = /* @__PURE__ */ ((AuditorType2) => {
+  AuditorType2[AuditorType2["PRIMARY"] = 0] = "PRIMARY";
+  AuditorType2[AuditorType2["REGULATORY"] = 1] = "REGULATORY";
+  AuditorType2[AuditorType2["INTERNAL"] = 2] = "INTERNAL";
+  AuditorType2[AuditorType2["TAX"] = 3] = "TAX";
+  return AuditorType2;
+})(AuditorType || {});
+var AuditorKeyDerivation = class {
+  /**
+   * SIP Protocol coin type (BIP-44 registered)
+   *
+   * Note: This is a placeholder. In production, register with SLIP-44:
+   * https://github.com/satoshilabs/slips/blob/master/slip-0044.md
+   */
+  static COIN_TYPE = 1234;
+  /**
+   * BIP-44 purpose field
+   */
+  static PURPOSE = 44;
+  /**
+   * Hardened derivation flag (2^31)
+   */
+  static HARDENED = 2147483648;
+  /**
+   * Generate BIP-44 derivation path
+   *
+   * @param auditorType - Type of auditor key
+   * @param account - Account index (default: 0)
+   * @returns BIP-44 style path string
+   *
+   * @example
+   * ```typescript
+   * AuditorKeyDerivation.derivePath(AuditorType.REGULATORY)
+   * // Returns: "m/44'/1234'/0'/1"
+   *
+   * AuditorKeyDerivation.derivePath(AuditorType.TAX, 5)
+   * // Returns: "m/44'/1234'/5'/3"
+   * ```
+   */
+  static derivePath(auditorType, account = 0) {
+    this.validateAuditorType(auditorType);
+    this.validateAccount(account);
+    return `m/${this.PURPOSE}'/${this.COIN_TYPE}'/${account}'/${auditorType}`;
   }
-  if (!params.publicKey?.trim()) {
-    throw new ValidationError(
-      "public key is required",
-      "publicKey",
-      void 0,
-      "SIP_2008" /* MISSING_REQUIRED */
-    );
+  /**
+   * Derive a viewing key for an auditor
+   *
+   * Uses BIP-32 style hierarchical deterministic key derivation:
+   * 1. Derive master key from seed
+   * 2. Harden purpose (44')
+   * 3. Harden coin type (1234')
+   * 4. Harden account index
+   * 5. Derive auditor type (non-hardened)
+   *
+   * @param params - Derivation parameters
+   * @returns Derived viewing key with metadata
+   *
+   * @throws {ValidationError} If parameters are invalid
+   *
+   * @example
+   * ```typescript
+   * const regulatoryKey = AuditorKeyDerivation.deriveViewingKey({
+   *   masterSeed: randomBytes(32),
+   *   auditorType: AuditorType.REGULATORY,
+   * })
+   *
+   * console.log(regulatoryKey.path) // "m/44'/1234'/0'/1"
+   * console.log(regulatoryKey.viewingKey.key) // "0x..."
+   * ```
+   */
+  static deriveViewingKey(params) {
+    const { masterSeed, auditorType, account = 0 } = params;
+    this.validateMasterSeed(masterSeed);
+    this.validateAuditorType(auditorType);
+    this.validateAccount(account);
+    const path = this.derivePath(auditorType, account);
+    const indices = [
+      this.PURPOSE | this.HARDENED,
+      // 44' (hardened)
+      this.COIN_TYPE | this.HARDENED,
+      // 1234' (hardened)
+      account | this.HARDENED,
+      // account' (hardened)
+      auditorType
+      // auditorType (non-hardened)
+    ];
+    const masterData = (0, import_hmac2.hmac)(import_sha5123.sha512, (0, import_utils25.utf8ToBytes)("SIP-MASTER-SEED"), masterSeed);
+    let currentKey = new Uint8Array(masterData.slice(0, 32));
+    let chainCode = new Uint8Array(masterData.slice(32, 64));
+    try {
+      for (let i = 0; i < indices.length; i++) {
+        const index = indices[i];
+        const derived = this.deriveChildKey(currentKey, chainCode, index);
+        if (i > 0) {
+          secureWipe(currentKey);
+        }
+        currentKey = new Uint8Array(derived.key);
+        chainCode = new Uint8Array(derived.chainCode);
+      }
+      const keyHex = `0x${(0, import_utils25.bytesToHex)(currentKey)}`;
+      const hashBytes = (0, import_sha25619.sha256)(currentKey);
+      const hash2 = `0x${(0, import_utils25.bytesToHex)(hashBytes)}`;
+      const viewingKey = {
+        key: keyHex,
+        path,
+        hash: hash2
+      };
+      return {
+        path,
+        viewingKey,
+        auditorType,
+        account
+      };
+    } finally {
+      secureWipe(currentKey);
+      secureWipe(chainCode);
+    }
   }
-  if (!params.scope) {
-    throw new ValidationError(
-      "audit scope is required",
-      "scope",
-      void 0,
-      "SIP_2008" /* MISSING_REQUIRED */
-    );
+  /**
+   * Derive multiple viewing keys at once
+   *
+   * Efficiently derives keys for multiple auditor types from the same
+   * master seed. This is more efficient than calling deriveViewingKey
+   * multiple times as it reuses intermediate derivations.
+   *
+   * @param params - Derivation parameters
+   * @returns Array of derived viewing keys
+   *
+   * @example
+   * ```typescript
+   * const keys = AuditorKeyDerivation.deriveMultiple({
+   *   masterSeed: randomBytes(32),
+   *   auditorTypes: [
+   *     AuditorType.PRIMARY,
+   *     AuditorType.REGULATORY,
+   *     AuditorType.INTERNAL,
+   *   ],
+   * })
+   *
+   * // keys[0] -> PRIMARY key (m/44'/1234'/0'/0)
+   * // keys[1] -> REGULATORY key (m/44'/1234'/0'/1)
+   * // keys[2] -> INTERNAL key (m/44'/1234'/0'/2)
+   * ```
+   */
+  static deriveMultiple(params) {
+    const { masterSeed, auditorTypes, account = 0 } = params;
+    this.validateMasterSeed(masterSeed);
+    this.validateAccount(account);
+    if (!auditorTypes || auditorTypes.length === 0) {
+      throw new ValidationError(
+        "at least one auditor type is required",
+        "auditorTypes",
+        { received: auditorTypes },
+        "SIP_2008" /* MISSING_REQUIRED */
+      );
+    }
+    for (const type of auditorTypes) {
+      this.validateAuditorType(type);
+    }
+    const uniqueTypes = Array.from(new Set(auditorTypes));
+    const commonIndices = [
+      this.PURPOSE | this.HARDENED,
+      // 44' (hardened)
+      this.COIN_TYPE | this.HARDENED,
+      // 1234' (hardened)
+      account | this.HARDENED
+      // account' (hardened)
+    ];
+    const masterData = (0, import_hmac2.hmac)(import_sha5123.sha512, (0, import_utils25.utf8ToBytes)("SIP-MASTER-SEED"), masterSeed);
+    let commonKey = new Uint8Array(masterData.slice(0, 32));
+    let commonChainCode = new Uint8Array(masterData.slice(32, 64));
+    try {
+      for (let i = 0; i < commonIndices.length; i++) {
+        const index = commonIndices[i];
+        const derived = this.deriveChildKey(commonKey, commonChainCode, index);
+        if (i > 0) {
+          secureWipe(commonKey);
+        }
+        commonKey = new Uint8Array(derived.key);
+        commonChainCode = new Uint8Array(derived.chainCode);
+      }
+      const results = [];
+      for (const auditorType of uniqueTypes) {
+        const derived = this.deriveChildKey(commonKey, commonChainCode, auditorType);
+        try {
+          const keyHex = `0x${(0, import_utils25.bytesToHex)(derived.key)}`;
+          const hashBytes = (0, import_sha25619.sha256)(derived.key);
+          const hash2 = `0x${(0, import_utils25.bytesToHex)(hashBytes)}`;
+          const path = this.derivePath(auditorType, account);
+          const viewingKey = {
+            key: keyHex,
+            path,
+            hash: hash2
+          };
+          results.push({
+            path,
+            viewingKey,
+            auditorType,
+            account
+          });
+        } finally {
+          secureWipe(derived.key);
+          secureWipe(derived.chainCode);
+        }
+      }
+      return results;
+    } finally {
+      secureWipe(commonKey);
+      secureWipe(commonChainCode);
+    }
   }
-}
-function validateReportParams(params) {
-  if (!params.title?.trim()) {
-    throw new ValidationError(
-      "report title is required",
-      "title",
-      void 0,
-      "SIP_2008" /* MISSING_REQUIRED */
-    );
+  /**
+   * Get human-readable name for auditor type
+   *
+   * @param auditorType - Auditor type enum value
+   * @returns Friendly name string
+   */
+  static getAuditorTypeName(auditorType) {
+    switch (auditorType) {
+      case 0 /* PRIMARY */:
+        return "Primary";
+      case 1 /* REGULATORY */:
+        return "Regulatory";
+      case 2 /* INTERNAL */:
+        return "Internal";
+      case 3 /* TAX */:
+        return "Tax Authority";
+      default:
+        return `Unknown (${auditorType})`;
+    }
   }
-  if (!params.type) {
-    throw new ValidationError(
-      "report type is required",
-      "type",
-      void 0,
-      "SIP_2008" /* MISSING_REQUIRED */
-    );
+  // ─── Private Helpers ─────────────────────────────────────────────────────────
+  /**
+   * Derive a child key using BIP-32 HMAC-SHA512 derivation
+   *
+   * @param parentKey - Parent key bytes (32 bytes)
+   * @param chainCode - Parent chain code (32 bytes)
+   * @param index - Child index (use | HARDENED for hardened derivation)
+   * @returns Derived key and chain code
+   */
+  static deriveChildKey(parentKey, chainCode, index) {
+    const isHardened = (index & this.HARDENED) !== 0;
+    const data = new Uint8Array(37);
+    if (isHardened) {
+      data[0] = 0;
+      data.set(parentKey, 1);
+    } else {
+      data[0] = 1;
+      data.set(parentKey, 1);
+    }
+    const indexView = new DataView(data.buffer, 33, 4);
+    indexView.setUint32(0, index, false);
+    const hmacResult = (0, import_hmac2.hmac)(import_sha5123.sha512, chainCode, data);
+    const childKey = new Uint8Array(hmacResult.slice(0, 32));
+    const childChainCode = new Uint8Array(hmacResult.slice(32, 64));
+    return {
+      key: childKey,
+      chainCode: childChainCode
+    };
   }
-  if (!params.format) {
-    throw new ValidationError(
-      "report format is required",
-      "format",
-      void 0,
-      "SIP_2008" /* MISSING_REQUIRED */
-    );
+  /**
+   * Validate master seed
+   */
+  static validateMasterSeed(seed) {
+    if (!seed || seed.length < 32) {
+      throw new ValidationError(
+        "master seed must be at least 32 bytes",
+        "masterSeed",
+        { received: seed?.length ?? 0 },
+        "SIP_2001" /* INVALID_INPUT */
+      );
+    }
   }
-  if (params.startDate === void 0 || params.startDate === null || params.endDate === void 0 || params.endDate === null) {
-    throw new ValidationError(
-      "date range is required",
-      "dateRange",
-      void 0,
-      "SIP_2008" /* MISSING_REQUIRED */
-    );
+  /**
+   * Validate auditor type
+   */
+  static validateAuditorType(type) {
+    const validTypes = [
+      0 /* PRIMARY */,
+      1 /* REGULATORY */,
+      2 /* INTERNAL */,
+      3 /* TAX */
+    ];
+    if (!validTypes.includes(type)) {
+      throw new ValidationError(
+        `invalid auditor type: ${type}`,
+        "auditorType",
+        { received: type, valid: validTypes },
+        "SIP_2001" /* INVALID_INPUT */
+      );
+    }
   }
-  if (params.startDate >= params.endDate) {
-    throw new ValidationError(
-      "start date must be before end date",
-      "dateRange",
-      void 0,
-      "SIP_2001" /* INVALID_INPUT */
-    );
+  /**
+   * Validate account index
+   */
+  static validateAccount(account) {
+    if (!Number.isInteger(account) || account < 0 || account >= this.HARDENED) {
+      throw new ValidationError(
+        `account must be a non-negative integer less than ${this.HARDENED}`,
+        "account",
+        { received: account },
+        "SIP_2001" /* INVALID_INPUT */
+      );
+    }
   }
-}
+};
 
 // src/wallet/errors.ts
 var import_types18 = require("@sip-protocol/types");
@@ -10624,6 +13156,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 */
@@ -10699,7 +13255,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";
@@ -10852,7 +13408,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
     );
   }
   /**
@@ -10863,7 +13419,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 ─────────────────────────────────────────────────────
@@ -11151,7 +13707,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";
@@ -11297,7 +13853,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
     );
   }
   /**
@@ -11308,7 +13864,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 ─────────────────────────────────────────────────────
@@ -11589,8 +14145,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_utils26 = require("@noble/hashes/utils");
 var MockLedgerAdapter = class extends BaseWalletAdapter {
   chain;
   name = "mock-ledger";
@@ -11737,7 +14293,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
     );
   }
   /**
@@ -11746,7 +14302,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
     );
   }
   /**
@@ -11835,15 +14391,15 @@ var MockLedgerAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = (0, import_utils15.randomBytes)(20);
+    const bytes = (0, import_utils26.randomBytes)(20);
     bytes[0] = index;
-    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils26.bytesToHex)(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = (0, import_utils15.randomBytes)(33);
+    const bytes = (0, import_utils26.randomBytes)(33);
     bytes[0] = 2;
     bytes[1] = index;
-    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils26.bytesToHex)(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -11852,7 +14408,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_utils26.bytesToHex)(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -11976,13 +14532,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) {
@@ -12041,15 +14597,15 @@ var MockTrezorAdapter = class extends BaseWalletAdapter {
     }
   }
   generateMockAddress(index) {
-    const bytes = (0, import_utils15.randomBytes)(20);
+    const bytes = (0, import_utils26.randomBytes)(20);
     bytes[0] = index + 100;
-    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils26.bytesToHex)(bytes)}`;
   }
   generateMockPublicKey(index) {
-    const bytes = (0, import_utils15.randomBytes)(33);
+    const bytes = (0, import_utils26.randomBytes)(33);
     bytes[0] = 3;
     bytes[1] = index + 100;
-    return `0x${(0, import_utils15.bytesToHex)(bytes)}`;
+    return `0x${(0, import_utils26.bytesToHex)(bytes)}`;
   }
   generateMockSignature(data) {
     const sig = new Uint8Array(65);
@@ -12058,7 +14614,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_utils26.bytesToHex)(sig)}`;
   }
   delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -12072,13 +14628,20 @@ 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,
+  AuditorKeyDerivation,
+  AuditorType,
   BaseWalletAdapter,
   CHAIN_NUMERIC_IDS,
+  COSMOS_CHAIN_PREFIXES,
   ComplianceManager,
+  ComplianceReporter,
+  ConditionalDisclosure,
+  CosmosStealthService,
   CryptoError,
   DEFAULT_THRESHOLD,
   DEFAULT_TOTAL_ORACLES,
@@ -12129,6 +14692,7 @@ var import_types36 = require("@sip-protocol/types");
   SmartRouter,
   SolanaWalletAdapter,
   SwapStatus,
+  ThresholdViewingKey,
   Treasury,
   TrezorWalletAdapter,
   ValidationError,
@@ -12143,17 +14707,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,
@@ -12172,6 +14740,7 @@ var import_types36 = require("@sip-protocol/types");
   createShieldedPayment,
   createSmartRouter,
   createSolanaAdapter,
+  createTaprootOutput,
   createTrezorAdapter,
   createWalletFactory,
   createZcashClient,
@@ -12179,8 +14748,10 @@ var import_types36 = require("@sip-protocol/types");
   createZcashShieldedService,
   createZcashSwapService,
   decodeStealthMetaAddress,
+  decodeTaprootAddress,
   decryptMemo,
   decryptWithViewing,
+  deriveAptosStealthPrivateKey,
   deriveEd25519StealthPrivateKey,
   deriveOracleId,
   deriveStealthPrivateKey,
@@ -12190,6 +14761,7 @@ var import_types36 = require("@sip-protocol/types");
   deserializePayment,
   detectEthereumWallets,
   detectSolanaWallets,
+  ed25519PublicKeyToAptosAddress,
   ed25519PublicKeyToNearAddress,
   ed25519PublicKeyToSolanaAddress,
   encodeStealthMetaAddress,
@@ -12198,10 +14770,14 @@ var import_types36 = require("@sip-protocol/types");
   formatStablecoinAmount,
   fromHex,
   fromStablecoinUnits,
+  generateAptosStealthAddress,
   generateBlinding,
+  generateCosmosStealthAddress,
+  generateCosmosStealthMetaAddress,
   generateEd25519StealthAddress,
   generateEd25519StealthMetaAddress,
   generateIntentId,
+  generatePdfReport,
   generateRandomBytes,
   generateStealthAddress,
   generateStealthMetaAddress,
@@ -12228,6 +14804,7 @@ var import_types36 = require("@sip-protocol/types");
   getStablecoinsForChain,
   getSupportedStablecoins,
   getTimeRemaining,
+  getXOnlyPublicKey,
   hasEnoughOracles,
   hasErrorCode,
   hasRequiredProofs,
@@ -12244,8 +14821,10 @@ var import_types36 = require("@sip-protocol/types");
   isStablecoin,
   isStablecoinOnChain,
   isValidAmount,
+  isValidAptosAddress,
   isValidChainId,
   isValidCompressedPublicKey,
+  isValidCosmosAddress,
   isValidEd25519PublicKey,
   isValidHex,
   isValidHexLength,
@@ -12257,12 +14836,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,
@@ -12271,6 +14855,7 @@ var import_types36 = require("@sip-protocol/types");
   signAttestationMessage,
   solanaAddressToEd25519PublicKey,
   solanaPublicKeyToHex,
+  stealthKeyToCosmosAddress,
   subtractBlindings,
   subtractCommitments,
   supportsSharedArrayBuffer,
@@ -12279,6 +14864,7 @@ var import_types36 = require("@sip-protocol/types");
   supportsWebHID,
   supportsWebUSB,
   supportsWebWorkers,
+  taprootAddress,
   toHex,
   toStablecoinUnits,
   trackIntent,