@gvnrdao/dh-lit-actions 0.0.33 → 0.0.34

package/out/btc-deposit-validator.js

@@ -1,1488 +0,0 @@
-// LIT Actions runtime provides: Lit, ethers, fetch
-var _LIT_ACTION_ = (() => {
-  // src/constants/chunks/liquidation.ts
-  var ACTIVE_LOAN_LIQUIDATION_THRESHOLD_BPS = 13e3;
-  var EXPIRED_LOAN_MIN_LIQUIDATION_THRESHOLD_BPS = 11e3;
-  var EXPIRED_LOAN_MAX_LIQUIDATION_THRESHOLD_BPS = 2e4;
-  var GRACE_PERIOD_DAYS = 30;
-
-  // src/constants/chunks/decimals.ts
-  var SATOSHIS_PER_BITCOIN = 100000000n;
-  var PRICE_ORACLE_DECIMALS = 100000000n;
-  var UCD_TOKEN_DECIMALS = 1000000000000000000n;
-
-  // src/constants/chunks/bitcoin.ts
-  var BITCOIN_DEFAULT_MIN_CONFIRMATIONS = 6;
-  var MAX_BTC_AMOUNT = 25e6 * 1e8;
-
-  // src/constants/chunks/quantum-time.ts
-  var QUANTUM_WINDOW_SECONDS = 100;
-  var DEAD_ZONE_SECONDS = 16;
-  var SAFE_EXECUTION_WINDOW_SECONDS = QUANTUM_WINDOW_SECONDS - DEAD_ZONE_SECONDS;
-
-  // deployments/deployment.sepolia.json
-  var deployment_sepolia_default = {
-    network: "sepolia",
-    chainId: 11155111,
-    timestamp: "2025-10-24T23:22:01.396Z",
-    deployer: "0x2767441E044aCd9bbC21a759fB0517494875092d",
-    contracts: {
-      UpgradeValidator: "0x4246830c4bF03a6f4460ecEB9e6470562a5Cd0bB",
-      UCDToken: "0x86060Fa5B3E01E003b8aFd9C1295F1F444a7dC60",
-      UCDController: "0xEE24c338e394610b503768Ba7D8A8c26efdD3Aeb",
-      PriceFeedConsumer: "0xA285198196B8f4f658DC81bf4e99A5DC6c191694",
-      BTCProofValidator: "0x79469590b41AF8b21276914da7f18FF136B59afB",
-      UCDMintingRewards: "0x914740bA9b454d1B3C116A9F55C0929487b7E052",
-      PositionManagerCoreModule: "0x0f7E84538026Efdd118168b27f6da00035c75697",
-      TermManagerModule: "0x73f0e9151bbEa3cB8b21628E2aAd54C3f6b3968A",
-      LoanOperationsManagerModule: "0x71128A4e728ca4B6976E05aC77E50Ad7fe98Ae37",
-      CollateralManagerModule: "0xAb9205f4b559F945Ae45c0857fc5c30d699509E1",
-      LiquidationManagerModule: "0xe5A72334ED5e0F962be02229b36685d5Bb331cCF",
-      CircuitBreakerModule: "0x55eE4Bb05008b73AebcAfa5FbC745348E645d8c6",
-      CommunityManagerModule: "0x4E4481B0B3B08804C1d32A19Af66130426D82e89",
-      AdminModule: "0xF96F14605f870A0cC2589A5d2b1D77E379762Af2",
-      PositionManagerViews: "0x7bc05DBC27BBdab374E3FEBB4Efaa6CDE082fc27",
-      PositionManager: "0xAC8d7b714865D4F304b80cd037b517796D56E4Ce",
-      MockUSDC: "0x43670cD40c3c4a7acBA5B06B84b8Dd97D7E08f82",
-      MockUSDT: "0xF8b7fB38b17a310960E47805Be9adba0b0e0394D",
-      SimplePSMV2: "0x8C2D7C833b40eD23Bf1EABAf8B9105C80FD686A2",
-      OperationAuthorizationRegistry: "0x400B85A6A901fdbF08f048cD5f3e37B8DD6c0D66"
-    },
-    upgraded: {
-      LoanOperationsManagerModule: {
-        previousImplementation: "0xFa3E83992d964E46d82Bb1F92844a8aC909130B2",
-        newImplementation: "0xFa3E83992d964E46d82Bb1F92844a8aC909130B2",
-        upgradedAt: "2025-10-24T23:22:01.396Z",
-        upgradedBy: "0x2767441E044aCd9bbC21a759fB0517494875092d"
-      }
-    }
-  };
-
-  // deployments/deployment.localhost.json
-  var deployment_localhost_default = {
-    network: "localhost",
-    chainId: 1337,
-    timestamp: "2025-10-19T17:53:35.461Z",
-    deployer: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-    contracts: {
-      UpgradeValidator: "0xa513E6E4b8f2a923D98304ec87F64353C4D5C853",
-      UCDToken: "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
-      UCDController: "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9",
-      PriceFeedConsumer: "0x8A791620dd6260079BF849Dc5567aDC3F2FdC318",
-      BTCProofValidator: "0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e",
-      UCDMintingRewards: "0x0DCd1Bf9A1b36cE34237eEaFef220932846BCD82",
-      PositionManagerCoreModule: "0x0B306BF915C4d645ff596e518fAf3F9669b97016",
-      TermManagerModule: "0x9A9f2CCfdE556A7E9Ff0848998Aa4a0CFD8863AE",
-      LoanOperationsManagerModule: "0x3Aa5ebB10DC797CAC828524e59A333d0A371443c",
-      CollateralManagerModule: "0x59b670e9fA9D0A427751Af201D676719a970857b",
-      LiquidationManagerModule: "0x322813Fd9A801c5507c9de605d63CEA4f2CE6c44",
-      CircuitBreakerModule: "0x4A679253410272dd5232B3Ff7cF5dbB88f295319",
-      CommunityManagerModule: "0x09635F643e140090A9A8Dcd712eD6285858ceBef",
-      AdminModule: "0x67d269191c92Caf3cD7723F116c85e6E9bf55933",
-      PositionManagerViews: "0xE6E340D132b5f46d1e472DebcD681B2aBc16e57E",
-      PositionManager: "0x84eA74d481Ee0A5332c457a4d796187F6Ba67fEB"
-    }
-  };
-
-  // src/config/network-config.ts
-  var NETWORK_DEPLOYMENTS = {
-    sepolia: deployment_sepolia_default,
-    localhost: deployment_localhost_default
-  };
-  function getNetworkConfig(network) {
-    const normalizedNetwork = network.toLowerCase();
-    if (!NETWORK_DEPLOYMENTS[normalizedNetwork]) {
-      console.warn(
-        `Warning: Network "${network}" not found, defaulting to sepolia`
-      );
-      return NETWORK_DEPLOYMENTS.sepolia;
-    }
-    return NETWORK_DEPLOYMENTS[normalizedNetwork];
-  }
-
-  // src/constants/chunks/bitcoin-network-config.ts
-  var EVMChain = /* @__PURE__ */ ((EVMChain3) => {
-    EVMChain3["SEPOLIA"] = "sepolia";
-    EVMChain3["ETHEREUM"] = "ethereum";
-    return EVMChain3;
-  })(EVMChain || {});
-  var CHAIN_TO_BITCOIN_NETWORK = {
-    ["sepolia" /* SEPOLIA */]: "regtest" /* REGTEST */,
-    ["ethereum" /* ETHEREUM */]: "mainnet" /* MAINNET */
-  };
-  var APPROVED_BITCOIN_PROVIDERS = {
-    ["regtest" /* REGTEST */]: [
-      {
-        url: "https://diamond-hands-btc-faucet-6b39a1072059.herokuapp.com/api",
-        network: "regtest" /* REGTEST */,
-        minConfirmations: 1,
-        name: "Diamond Hands"
-      },
-      {
-        url: "http://diamond-hands-btc-faucet-6b39a1072059.herokuapp.com/api",
-        network: "regtest" /* REGTEST */,
-        minConfirmations: 1,
-        name: "Diamond Hands"
-      }
-    ],
-    ["testnet" /* TESTNET */]: [
-      {
-        url: "https://diamond-hands-btc-faucet-6b39a1072059.herokuapp.com/api",
-        network: "testnet" /* TESTNET */,
-        minConfirmations: 1,
-        name: "Diamond Hands"
-      },
-      {
-        url: "http://diamond-hands-btc-faucet-6b39a1072059.herokuapp.com/api",
-        network: "testnet" /* TESTNET */,
-        minConfirmations: 1,
-        name: "Diamond Hands"
-      }
-    ],
-    ["mainnet" /* MAINNET */]: [
-      {
-        url: "https://blockstream.info/api",
-        network: "mainnet" /* MAINNET */,
-        minConfirmations: 6,
-        name: "Blockstream Mainnet"
-      },
-      {
-        url: "https://mempool.space/api",
-        network: "mainnet" /* MAINNET */,
-        minConfirmations: 6,
-        name: "Mempool.space Mainnet"
-      }
-    ]
-  };
-  function validateChain(chain) {
-    const normalized = chain.toLowerCase().trim();
-    if (normalized === "sepolia") {
-      return "sepolia" /* SEPOLIA */;
-    }
-    if (normalized === "ethereum" || normalized === "mainnet") {
-      return "ethereum" /* ETHEREUM */;
-    }
-    throw new Error(
-      `Unsupported EVM chain: "${chain}". Supported chains: ${Object.values(EVMChain).join(", ")}`
-    );
-  }
-  function getBitcoinNetworkForChain(chain) {
-    return CHAIN_TO_BITCOIN_NETWORK[chain];
-  }
-  function validateBitcoinProvider(providerUrl, bitcoinNetwork) {
-    const providers = APPROVED_BITCOIN_PROVIDERS[bitcoinNetwork];
-    const config = providers.find((p) => p.url === providerUrl);
-    if (!config) {
-      const approvedUrls = providers.map((p) => `${p.name} (${p.url})`).join(", ");
-      throw new Error(
-        `Bitcoin provider not approved for ${bitcoinNetwork}. Provided URL: ${providerUrl}. Approved providers: ${approvedUrls}`
-      );
-    }
-    return config;
-  }
-  function getBitcoinProviderConfig(chain, providerUrl) {
-    const validatedChain = validateChain(chain);
-    const bitcoinNetwork = getBitcoinNetworkForChain(validatedChain);
-    const providerConfig = validateBitcoinProvider(providerUrl, bitcoinNetwork);
-    if (providerConfig.network !== bitcoinNetwork) {
-      throw new Error(
-        `Bitcoin provider network mismatch. Provider ${providerConfig.name} is for ${providerConfig.network}, but chain ${chain} requires ${bitcoinNetwork}`
-      );
-    }
-    return providerConfig;
-  }
-
-  // src/modules/bitcoin-data-provider.module.ts
-  var DEFAULT_MIN_CONFIRMATIONS = BITCOIN_DEFAULT_MIN_CONFIRMATIONS;
-  var BitcoinDataProvider = class {
-    constructor(config) {
-      this.config = config;
-      this.timeout = config.timeout || 1e4;
-    }
-    /**
-     * Fetch all UTXOs for a Bitcoin address
-     *
-     * @param address - Bitcoin address (legacy, segwit, or taproot)
-     * @returns Array of UTXOs
-     */
-    async getUTXOs(address) {
-      console.log(`[Bitcoin Data] Original address: "${address}"`);
-      const cleanAddress = this.stripNetworkPrefix(address);
-      console.log(`[Bitcoin Data] Cleaned address: "${cleanAddress}"`);
-      if (this.config.rpcHelper) {
-        return await this.fetchUTXOsFromRPC(cleanAddress);
-      }
-      try {
-        return await this.fetchUTXOsFromProvider(
-          this.config.providerUrl,
-          cleanAddress
-        );
-      } catch (error) {
-        console.warn(`[Bitcoin Data] Primary provider failed: ${error.message}`);
-        if (this.config.fallbackProviders && this.config.fallbackProviders.length > 0) {
-          const sortedFallbacks = [...this.config.fallbackProviders].sort(
-            (a, b) => a.priority - b.priority
-          );
-          for (const fallback of sortedFallbacks) {
-            try {
-              console.log(
-                `[Bitcoin Data] Trying fallback: ${fallback.name} (${fallback.url})`
-              );
-              return await this.fetchUTXOsFromProvider(fallback.url, cleanAddress);
-            } catch (fallbackError) {
-              console.warn(
-                `[Bitcoin Data] Fallback ${fallback.name} failed: ${fallbackError.message}`
-              );
-              continue;
-            }
-          }
-        }
-        throw new Error(`Failed to fetch UTXOs: ${error.message}`);
-      }
-    }
-    /**
-     * Strip network prefix from Bitcoin address
-     *
-     * Addresses may be stored with network prefix (e.g., "REGTEST_address")
-     * but APIs expect clean addresses without prefix.
-     *
-     * @param address - Address with optional prefix
-     * @returns Clean address without prefix
-     */
-    stripNetworkPrefix(address) {
-      const prefixPattern = /^(REGTEST_|TESTNET_|MAINNET_)/;
-      return address.replace(prefixPattern, "");
-    }
-    /**
-     * Fetch UTXOs using Bitcoin RPC (for regtest/testing)
-     */
-    async fetchUTXOsFromRPC(address) {
-      if (!this.config.rpcHelper) {
-        throw new Error("RPC helper not configured");
-      }
-      const wallet = this.config.rpcWallet || "";
-      const unspentOutputs = await this.config.rpcHelper.listUnspent(
-        wallet,
-        address
-      );
-      const utxos = unspentOutputs.map((utxo) => ({
-        txid: utxo.txid,
-        vout: utxo.vout,
-        satoshis: BigInt(Math.round(utxo.amount * 1e8)),
-        // BTC to satoshis as bigint
-        confirmations: utxo.confirmations
-      }));
-      return utxos;
-    }
-    /**
-     * Parse Diamond Hands Faucet UTXO response
-     *
-     * Expected format:
-     * {
-     *   "success": true,
-     *   "address": "...",
-     *   "utxos": [{txid, vout, amount, confirmations, scriptPubKey}],
-     *   "totalBalance": 33000000,
-     *   "utxoCount": 6
-     * }
-     *
-     * @param data Raw response from faucet API
-     * @returns Array of normalized UTXOs
-     */
-    parseDiamondHandsFaucetUTXOs(data) {
-      if (!data.success) {
-        throw new Error(
-          `Diamond Hands Faucet error: ${data.error || data.message || "Unknown error"}`
-        );
-      }
-      if (!Array.isArray(data.utxos)) {
-        throw new Error(
-          "Invalid Diamond Hands Faucet response: utxos must be an array"
-        );
-      }
-      const utxos = data.utxos.map((utxo) => ({
-        txid: utxo.txid,
-        vout: utxo.vout,
-        satoshis: BigInt(utxo.amount),
-        // Faucet uses "amount" (satoshis)
-        confirmations: utxo.confirmations || 0
-      }));
-      return utxos;
-    }
-    /**
-     * Parse Blockstream/Mempool.space UTXO response
-     *
-     * Expected format: Array of {txid, vout, value, confirmations}
-     *
-     * @param data Raw response from provider API
-     * @returns Array of normalized UTXOs
-     */
-    parseBlockstreamUTXOs(data) {
-      if (!Array.isArray(data)) {
-        throw new Error(
-          "Invalid Blockstream response format: expected an array"
-        );
-      }
-      const utxos = data.map((utxo) => ({
-        txid: utxo.txid,
-        vout: utxo.vout !== void 0 ? utxo.vout : utxo.n,
-        satoshis: BigInt(utxo.value !== void 0 ? utxo.value : utxo.satoshis),
-        confirmations: utxo.confirmations || 0
-      }));
-      return utxos;
-    }
-    /**
-     * Internal method to fetch UTXOs from a specific provider
-     *
-     * Supports multiple provider API formats:
-     * - Blockstream/Mempool.space: /api/address/{address}/utxos
-     * - Diamond Hands Faucet: /api/faucet/utxos/{address}
-     */
-    async fetchUTXOsFromProvider(providerUrl, address) {
-      const allProviders = Object.values(APPROVED_BITCOIN_PROVIDERS).flat();
-      const matched = allProviders.find((p) => p.url === providerUrl);
-      const providerName = matched?.name || providerUrl;
-      let endpoint;
-      if (providerName === "Diamond Hands") {
-        endpoint = `${providerUrl}/faucet/balance/${address}/utxos`;
-      } else {
-        endpoint = `${providerUrl}/address/${address}/utxos`;
-      }
-      console.log(`Fetching UTXOs from ${endpoint}`);
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-      try {
-        const response = await fetch(endpoint, {
-          signal: controller.signal,
-          headers: {
-            "Accept": "application/json",
-            "Content-Type": "application/json"
-          }
-        });
-        clearTimeout(timeoutId);
-        if (!response.ok) {
-          throw new Error(
-            `Bitcoin provider error: ${response.status} ${response.statusText}`
-          );
-        }
-        const data = await response.json();
-        console.log(`[Line 222 Context] Raw API Response:`, JSON.stringify(data, null, 2));
-        if (providerName === "Diamond Hands") {
-          return this.parseDiamondHandsFaucetUTXOs(data);
-        } else {
-          return this.parseBlockstreamUTXOs(data);
-        }
-      } catch (error) {
-        clearTimeout(timeoutId);
-        if (error.name === "AbortError") {
-          throw new Error(`Request timeout after ${this.timeout}ms`);
-        }
-        throw error;
-      }
-    }
-    /**
-     * Get complete UTXO set with balance summary
-     *
-     * This is the SINGLE method that vault-balance module should call.
-     * Returns everything needed to know about Bitcoin network state for an address.
-     *
-     * @param address - Bitcoin address
-     * @param minConfirmations - Minimum confirmations for "confirmed" status (default: 6)
-     * @returns Complete UTXO set with balance breakdown
-     */
-    async getUTXOSet(address, minConfirmations = DEFAULT_MIN_CONFIRMATIONS) {
-      const utxos = await this.getUTXOs(address);
-      const totalBalance = utxos.reduce((sum, utxo) => sum + utxo.satoshis, 0n);
-      const confirmedBalance = utxos.filter((utxo) => utxo.confirmations >= minConfirmations).reduce((sum, utxo) => sum + utxo.satoshis, 0n);
-      const unconfirmedBalance = totalBalance - confirmedBalance;
-      return {
-        utxos,
-        totalBalance,
-        totalUTXOs: utxos.length,
-        confirmedBalance,
-        unconfirmedBalance
-      };
-    }
-    /**
-     * Get transaction with confirmation count
-     *
-     * Checks if transaction exists on Bitcoin network and returns confirmation count.
-     * Used to validate authorized spends have been broadcasted.
-     *
-     * @param txid - Transaction ID to check
-     * @returns Transaction with confirmation count, or null if not found
-     */
-    async getTransaction(txid) {
-      if (this.config.rpcHelper) {
-        try {
-          const wallet = this.config.rpcWallet || "";
-          const tx = await this.config.rpcHelper.getTransaction(wallet, txid);
-          return {
-            txid: tx.txid,
-            confirmations: tx.confirmations || 0
-          };
-        } catch (error) {
-          if (error.message?.includes("Invalid or non-wallet transaction") || error.code === -5) {
-            return null;
-          }
-          throw error;
-        }
-      }
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-      try {
-        const response = await fetch(
-          `${this.config.providerUrl}/api/tx/${txid}`,
-          {
-            signal: controller.signal
-          }
-        );
-        clearTimeout(timeoutId);
-        if (!response.ok) {
-          if (response.status === 404) {
-            return null;
-          }
-          throw new Error(
-            `Bitcoin provider error: ${response.status} ${response.statusText}`
-          );
-        }
-        const data = await response.json();
-        if (data.status) {
-          return {
-            txid: data.txid,
-            confirmations: data.status.confirmed ? data.status.block_height ? 1 : 0 : 0
-          };
-        }
-        return null;
-      } catch (error) {
-        clearTimeout(timeoutId);
-        if (error.name === "AbortError") {
-          throw new Error(`Request timeout after ${this.timeout}ms`);
-        }
-        if (error.message?.includes("404")) {
-          return null;
-        }
-        throw error;
-      }
-    }
-    // FUTURE: Multi-provider consensus methods will be added here
-    // async getUTXOsWithConsensus(address: string): Promise<UTXO[]> {
-    //   // Fetch from all providers
-    //   // Return UTXOs that appear in 2+ sources
-    //   // Use median value if amounts differ
-    // }
-  };
-
-  // src/modules/price-oracle.module.ts
-  var PriceOracleModule = class {
-    constructor(options, sources) {
-      this.mode = options?.mode || "full";
-      this.sources = sources || this.getDefaultSources();
-      this.sources.sort((a, b) => a.priority - b.priority);
-    }
-    getDefaultSources() {
-      const DEFAULT_HEADERS = {
-        "User-Agent": "diamond-hands-lit-action/1.0",
-        Accept: "application/json"
-      };
-      const fetchJson = async (url) => {
-        const controller = new AbortController();
-        const timeoutMs = this.mode === "fast" ? 4e3 : 8e3;
-        const id = setTimeout(() => controller.abort(), timeoutMs);
-        try {
-          const res = await fetch(url, { headers: DEFAULT_HEADERS, signal: controller.signal });
-          if (!res.ok) {
-            throw new Error(`HTTP ${res.status} ${res.statusText}`);
-          }
-          return await res.json();
-        } finally {
-          clearTimeout(id);
-        }
-      };
-      return [
-        {
-          name: "CoinGecko",
-          fetchPrice: async () => {
-            const url = new URL("https://api.coingecko.com/api/v3/simple/price");
-            url.searchParams.set("ids", "bitcoin");
-            url.searchParams.set("vs_currencies", "usd");
-            const data = await fetchJson(url.toString());
-            const price = Number(data?.bitcoin?.usd);
-            if (!Number.isFinite(price) || price <= 0) {
-              throw new Error("Invalid CoinGecko price payload");
-            }
-            if (this.mode !== "fast") {
-              const allPrices = await Lit.Actions.broadcastAndCollect({
-                name: "coinGeckoPrice",
-                value: price.toString()
-              });
-              const prices = allPrices.map((p) => parseFloat(p));
-              prices.sort((a, b) => a - b);
-              return prices[Math.floor(prices.length / 2)];
-            }
-            return price;
-          },
-          priority: 1
-        },
-        {
-          name: "Binance",
-          fetchPrice: async () => {
-            const url = new URL("https://api.binance.com/api/v3/ticker/price");
-            url.searchParams.set("symbol", "BTCUSDT");
-            const data = await fetchJson(url.toString());
-            const price = Number(data?.price);
-            if (!Number.isFinite(price) || price <= 0) {
-              throw new Error("Invalid Binance price payload");
-            }
-            if (this.mode !== "fast") {
-              const allPrices = await Lit.Actions.broadcastAndCollect({
-                name: "binancePrice",
-                value: price.toString()
-              });
-              const prices = allPrices.map((p) => parseFloat(p));
-              prices.sort((a, b) => a - b);
-              return prices[Math.floor(prices.length / 2)];
-            }
-            return price;
-          },
-          priority: 2
-        },
-        {
-          name: "Coinbase",
-          fetchPrice: async () => {
-            const data = await fetchJson("https://api.coinbase.com/v2/prices/BTC-USD/spot");
-            const price = Number(data?.data?.amount);
-            if (!Number.isFinite(price) || price <= 0) {
-              throw new Error("Invalid Coinbase price payload");
-            }
-            if (this.mode !== "fast") {
-              const allPrices = await Lit.Actions.broadcastAndCollect({
-                name: "coinbasePrice",
-                value: price.toString()
-              });
-              const prices = allPrices.map((p) => parseFloat(p));
-              prices.sort((a, b) => a - b);
-              return prices[Math.floor(prices.length / 2)];
-            }
-            return price;
-          },
-          priority: 3
-        }
-      ];
-    }
-    /**
-     * Get BTC price in USD with 8 decimals
-     * Fetches from real price sources in priority order
-     */
-    async getBTCPrice() {
-      console.log(`[Price Oracle] Fetching BTC price from external sources...`);
-      for (const source of this.sources) {
-        try {
-          console.log(`[Price Oracle] Trying ${source.name}...`);
-          const priceUSD = await source.fetchPrice();
-          console.log(
-            `[Price Oracle] \u2705 ${source.name}: $${priceUSD.toLocaleString()}`
-          );
-          const priceWith8Decimals = BigInt(Math.floor(priceUSD * 1e8));
-          console.log(
-            `[Price Oracle] Price with 8 decimals: ${priceWith8Decimals}`
-          );
-          return priceWith8Decimals;
-        } catch (error) {
-          console.warn(
-            `[Price Oracle] \u26A0\uFE0F  ${source.name} failed: ${error.message}`
-          );
-          continue;
-        }
-      }
-      throw new Error("All price sources failed");
-    }
-    /**
-     * Consensus across multiple sources with outlier detection
-     * Returns median price from valid sources after filtering outliers
-     *
-     * Master's Wisdom: Two-Path Validation
-     * 1. If ONE source is outlier (>2% from median) → FILTER it, continue with remaining
-     * 2. If ALL sources too dispersed (>5% spread) → REJECT all, throw error
-     *
-     * Logic Flow:
-     * 1. Calculate initial median from all sources
-     * 2. Filter individual outliers (>2% from median)
-     * 3. If outliers found: remove them, require minimum 2 sources remaining
-     * 4. Recalculate median from valid sources only
-     * 5. Check if remaining sources are too dispersed (max/min ratio > 1.05)
-     * 6. Return final median or throw appropriate error
-     */
-    async getBTCPriceConsensus() {
-      console.log(`[Price Oracle] Fetching BTC price with consensus...`);
-      const OUTLIER_DEVIATION = 5e-3;
-      const DISPERSION_THRESHOLD = 0.05;
-      const results = await Promise.allSettled(
-        this.sources.map(async (source) => {
-          const price = await source.fetchPrice();
-          return { source: source.name, price };
-        })
-      );
-      const successful = results.filter((r) => r.status === "fulfilled").map((r) => r.value);
-      if (successful.length === 0) {
-        throw new Error("No price sources returned data");
-      }
-      console.log(
-        `[Price Oracle] Got prices from ${successful.length}/${this.sources.length} sources:`
-      );
-      successful.forEach((s) => {
-        console.log(`   ${s.source}: $${s.price.toLocaleString()}`);
-      });
-      const prices = successful.map((s) => s.price);
-      prices.sort((a, b) => a - b);
-      const initialMedian = prices[Math.floor(prices.length / 2)];
-      const minPrice = prices[0];
-      const maxPrice = prices[prices.length - 1];
-      const dispersionRatio = maxPrice / minPrice;
-      const validPrices = successful.filter((s) => {
-        const deviation = Math.abs(s.price - initialMedian) / initialMedian;
-        return deviation <= OUTLIER_DEVIATION;
-      });
-      if (dispersionRatio > 1 + DISPERSION_THRESHOLD && validPrices.length === successful.length) {
-        throw new Error(
-          `Price consensus failed: sources too dispersed (${((dispersionRatio - 1) * 100).toFixed(1)}% spread)`
-        );
-      }
-      if (validPrices.length < successful.length) {
-        const outliers = successful.filter(
-          (s) => !validPrices.find((v) => v.source === s.source)
-        );
-        console.log(`[Price Oracle] \u26A0\uFE0F  Detected ${outliers.length} outlier(s):`);
-        outliers.forEach((o) => {
-          const deviation = Math.abs(o.price - initialMedian) / initialMedian;
-          console.log(
-            `   ${o.source}: $${o.price.toLocaleString()} (${(deviation * 100).toFixed(1)}% deviation)`
-          );
-        });
-        if (validPrices.length < 2) {
-          throw new Error(
-            "Price consensus failed: insufficient valid sources after outlier removal"
-          );
-        }
-        console.log(
-          `[Price Oracle] \u2705 Outliers filtered, continuing with ${validPrices.length} valid sources`
-        );
-        const validPricesOnly = validPrices.map((v) => v.price);
-        validPricesOnly.sort((a, b) => a - b);
-        const finalMedian = validPricesOnly[Math.floor(validPricesOnly.length / 2)];
-        console.log(
-          `[Price Oracle] \u2705 Consensus price (median): $${finalMedian.toLocaleString()}`
-        );
-        return BigInt(Math.floor(finalMedian * 1e8));
-      }
-      console.log(
-        `[Price Oracle] \u2705 Consensus price (median): $${initialMedian.toLocaleString()}`
-      );
-      return BigInt(Math.floor(initialMedian * 1e8));
-    }
-  };
-
-  // src/modules/vault-balance.module.ts
-  var VaultBalanceModule = class {
-    constructor(config) {
-      this.config = config;
-      this.bitcoinProvider = config.bitcoinProvider;
-    }
-    /**
-     * Calculate trusted balance for a position
-     *
-     * This is the main entry point for determining available balance.
-     *
-     * CRITICAL: Validates that all authorized spends have been properly broadcasted
-     * to Bitcoin network with sufficient confirmations. Throws errors if:
-     * 1. Authorized transaction not found on network (not broadcasted)
-     * 2. Authorized transaction has insufficient confirmations (network updating)
-     *
-     * @param positionId - The position ID to check
-     * @param vaultAddress - Bitcoin address of the vault
-     * @returns Complete breakdown of vault balance
-     * @throws Error if authorized spends are in invalid state
-     */
-    async calculateTrustedBalance(positionId, vaultAddress) {
-      const minConfirmations = this.config.minConfirmations || 6;
-      const utxoSet = await this.bitcoinProvider.getUTXOSet(
-        vaultAddress,
-        minConfirmations
-      );
-      const authorizedSpends = await this.getAuthorizedSpendsFromContract(positionId);
-      for (const spend of authorizedSpends) {
-        const utxoStillExists = utxoSet.utxos.some(
-          (utxo) => utxo.txid === spend.txid && utxo.vout === spend.vout
-        );
-        if (utxoStillExists) {
-          throw new Error(
-            `Authorized UTXO ${spend.txid}:${spend.vout} not yet spent. Transaction was authorized in smart contract but not signed and broadcasted to Bitcoin network. Complete the transaction by signing and broadcasting it.`
-          );
-        }
-      }
-      const authorizedBalance = authorizedSpends.reduce(
-        (sum, spend) => sum + spend.satoshis,
-        0n
-      );
-      const availableUTXOs = utxoSet.utxos.filter(
-        (utxo) => !this.isUTXOAuthorized(utxo, authorizedSpends)
-      );
-      const availableBalance = availableUTXOs.reduce(
-        (sum, utxo) => sum + utxo.satoshis,
-        0n
-      );
-      return {
-        // Total from Bitcoin
-        totalUTXOs: utxoSet.utxos,
-        totalBalance: utxoSet.totalBalance,
-        // Authorized from Contract
-        authorizedUTXOs: authorizedSpends,
-        authorizedBalance,
-        // Available = Total - Authorized (THIS IS THE TRUSTED BALANCE)
-        availableUTXOs,
-        availableBalance,
-        // Metadata
-        vaultAddress,
-        positionId,
-        timestamp: Date.now()
-      };
-    }
-    /**
-     * Get just the trusted balance amount
-     *
-     * Convenience method when you only need the number.
-     *
-     * @param positionId - The position ID to check
-     * @param vaultAddress - Bitcoin address of the vault
-     * @returns Available balance in satoshis
-     */
-    async getTrustedBalance(positionId, vaultAddress) {
-      const result = await this.calculateTrustedBalance(positionId, vaultAddress);
-      return result.availableBalance;
-    }
-    /**
-     * Get available UTXOs that can be used for new authorizations
-     *
-     * This is useful when you need to select specific UTXOs for authorization.
-     *
-     * @param positionId - The position ID to check
-     * @param vaultAddress - Bitcoin address of the vault
-     * @returns Array of available UTXOs
-     */
-    async getAvailableUTXOs(positionId, vaultAddress) {
-      const result = await this.calculateTrustedBalance(positionId, vaultAddress);
-      return result.availableUTXOs;
-    }
-    /**
-     * Check if a specific UTXO is available for authorization
-     *
-     * @param positionId - The position ID to check
-     * @param vaultAddress - Bitcoin address of the vault
-     * @param txid - Transaction ID of the UTXO
-     * @param vout - Output index of the UTXO
-     * @returns True if UTXO is available, false otherwise
-     */
-    async isUTXOAvailable(positionId, vaultAddress, txid, vout) {
-      const availableUTXOs = await this.getAvailableUTXOs(
-        positionId,
-        vaultAddress
-      );
-      return availableUTXOs.some(
-        (utxo) => utxo.txid === txid && utxo.vout === vout
-      );
-    }
-    /**
-     * Check if a UTXO is authorized (appears in authorized spends)
-     *
-     * @param utxo - The UTXO to check
-     * @param authorizedSpends - List of authorized spends from contract
-     * @returns True if UTXO is authorized, false otherwise
-     */
-    isUTXOAuthorized(utxo, authorizedSpends) {
-      return authorizedSpends.some(
-        (spend) => spend.txid === utxo.txid && spend.vout === utxo.vout
-      );
-    }
-    /**
-     * Query smart contract for authorized spends
-     *
-     * Calls the contract's getAuthorizedSpends(positionId) view function
-     * to retrieve all authorized Bitcoin spends for this position.
-     *
-     * Contract struct AuthorizedSpend:
-     * - txid: string
-     * - vout: uint32
-     * - satoshis: uint256
-     * - authorizedAt: uint256 (timestamp)
-     *
-     * @param positionId - The position ID to query
-     * @returns Array of authorized spends for this position
-     */
-    async getAuthorizedSpendsFromContract(positionId) {
-      const positionIdBytes32 = positionId.startsWith("0x") ? positionId : `0x${positionId.padStart(64, "0")}`;
-      const getAuthorizedSpendsABI = [
-        {
-          inputs: [
-            { internalType: "bytes32", name: "positionId", type: "bytes32" }
-          ],
-          name: "getAuthorizedSpends",
-          outputs: [
-            {
-              components: [
-                { internalType: "string", name: "txid", type: "string" },
-                { internalType: "uint32", name: "vout", type: "uint32" },
-                { internalType: "uint256", name: "satoshis", type: "uint256" },
-                {
-                  internalType: "string",
-                  name: "targetAddress",
-                  type: "string"
-                },
-                {
-                  internalType: "uint256",
-                  name: "targetAmount",
-                  type: "uint256"
-                },
-                {
-                  internalType: "string",
-                  name: "changeAddress",
-                  type: "string"
-                },
-                {
-                  internalType: "uint256",
-                  name: "authorizedAt",
-                  type: "uint256"
-                }
-              ],
-              internalType: "struct LoanOperationsManager.AuthorizedSpend[]",
-              name: "",
-              type: "tuple[]"
-            }
-          ],
-          stateMutability: "view",
-          type: "function"
-        }
-      ];
-      let rpcUrl;
-      if (this.config.rpcUrl) {
-        rpcUrl = this.config.rpcUrl;
-      } else {
-        rpcUrl = await Lit.Actions.getRpcUrl({ chain: this.config.chain });
-      }
-      const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
-      const contract = new ethers.Contract(
-        this.config.contractAddress,
-        getAuthorizedSpendsABI,
-        provider
-      );
-      const result = await contract.getAuthorizedSpends(positionIdBytes32);
-      return result.map((spend) => ({
-        txid: spend.txid,
-        vout: Number(spend.vout),
-        satoshis: BigInt(spend.satoshis.toString()),
-        positionId,
-        targetAddress: spend.targetAddress,
-        targetAmount: BigInt(spend.targetAmount.toString()),
-        changeAddress: spend.changeAddress,
-        timestamp: Number(spend.authorizedAt)
-      }));
-    }
-  };
-  function createVaultBalanceModule(config) {
-    return new VaultBalanceModule(config);
-  }
-
-  // src/modules/business-rules-math.module.ts
-  function calculateTermStartFromExpiry(expiryTimestamp, termLengthMonths) {
-    if (expiryTimestamp === 0) {
-      return 0;
-    }
-    const SECONDS_PER_DAY = 86400;
-    const DAYS_PER_MONTH = 30;
-    const termDurationSeconds = termLengthMonths * DAYS_PER_MONTH * SECONDS_PER_DAY;
-    return expiryTimestamp - termDurationSeconds;
-  }
-  function calculateTermStatus(termStartTimestamp, selectedTermMonths) {
-    if (termStartTimestamp === 0) {
-      return {
-        termDurationDays: 0,
-        termLengthDays: selectedTermMonths * 30,
-        isExpired: false,
-        daysUntilExpiry: selectedTermMonths * 30,
-        daysIntoGracePeriod: 0
-      };
-    }
-    const now = Math.floor(Date.now() / 1e3);
-    const termLengthDays = selectedTermMonths * 30;
-    const termDurationSeconds = now - termStartTimestamp;
-    const termDurationDays = Math.floor(termDurationSeconds / 86400);
-    const isExpired = termDurationDays > termLengthDays;
-    const daysUntilExpiry = Math.max(0, termLengthDays - termDurationDays);
-    const daysIntoGracePeriod = Math.max(0, termDurationDays - termLengthDays);
-    return {
-      termDurationDays,
-      termLengthDays,
-      isExpired,
-      daysUntilExpiry,
-      daysIntoGracePeriod
-    };
-  }
-  function calculateLiquidationThreshold(isExpired, daysIntoGracePeriod) {
-    if (!isExpired) {
-      return ACTIVE_LOAN_LIQUIDATION_THRESHOLD_BPS;
-    }
-    const day = Math.min(daysIntoGracePeriod, GRACE_PERIOD_DAYS);
-    const daySquared = day * day;
-    const escalation = daySquared * (EXPIRED_LOAN_MAX_LIQUIDATION_THRESHOLD_BPS - EXPIRED_LOAN_MIN_LIQUIDATION_THRESHOLD_BPS) / (GRACE_PERIOD_DAYS * GRACE_PERIOD_DAYS);
-    const threshold = EXPIRED_LOAN_MIN_LIQUIDATION_THRESHOLD_BPS + escalation;
-    return threshold;
-  }
-  function calculateCollateralMetrics(availableBTCSats, btcPriceUsd, ucdDebt) {
-    if (ucdDebt === 0n) {
-      return {
-        collateralValueUsd: 0n,
-        collateralRatioBps: Number.MAX_SAFE_INTEGER
-      };
-    }
-    const collateralValueUsd = availableBTCSats * btcPriceUsd / (SATOSHIS_PER_BITCOIN * PRICE_ORACLE_DECIMALS);
-    const ratioBigInt = collateralValueUsd * UCD_TOKEN_DECIMALS * 10000n / ucdDebt;
-    const collateralRatioBps = Number(ratioBigInt);
-    return {
-      collateralValueUsd,
-      collateralRatioBps
-    };
-  }
-  function hasSufficientCollateralForDebt(collateralValueUsd, currentDebt, additionalDebt, requiredRatioBps) {
-    const newTotalDebt = currentDebt + additionalDebt;
-    if (newTotalDebt === 0n) {
-      return true;
-    }
-    const newCollateralRatioBps = Number(
-      collateralValueUsd * UCD_TOKEN_DECIMALS * 10000n / newTotalDebt
-    );
-    return newCollateralRatioBps >= requiredRatioBps;
-  }
-
-  // src/modules/protocol-parameters.module.ts
-  var ProtocolParametersModule = class {
-    constructor(config) {
-      this.termManagerAddress = config.termManagerAddress;
-      this.loanOpsManagerAddress = config.loanOpsManagerAddress;
-      this.chain = config.chain;
-    }
-    /**
-     * Get liquidation threshold from LoanOperationsManager
-     *
-     * @returns Liquidation threshold in basis points
-     */
-    async getLiquidationThreshold() {
-      try {
-        const rpcUrl = await Lit.Actions.getRpcUrl({ chain: this.chain });
-        const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
-        const abi = [
-          {
-            inputs: [],
-            name: "liquidationThreshold",
-            outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-            stateMutability: "view",
-            type: "function"
-          }
-        ];
-        const contract = new ethers.Contract(this.loanOpsManagerAddress, abi, provider);
-        const result = await contract.liquidationThreshold();
-        return Number(result.toString());
-      } catch (error) {
-        console.error(
-          "[ProtocolParameters] Error fetching liquidation threshold:",
-          error.message
-        );
-        throw new Error(
-          `Failed to fetch liquidation threshold: ${error.message}`
-        );
-      }
-    }
-    /**
-     * Get term-specific fees from TermManager
-     *
-     * @param termMonths Loan term in months
-     * @returns Term fees (origination and extension) in basis points
-     */
-    async getTermFees(termMonths) {
-      try {
-        const rpcUrl = await Lit.Actions.getRpcUrl({ chain: this.chain });
-        const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
-        const abi = [
-          {
-            inputs: [
-              { internalType: "uint256", name: "_termMonths", type: "uint256" }
-            ],
-            name: "getTermFees",
-            outputs: [
-              { internalType: "uint88", name: "originationFee", type: "uint88" },
-              { internalType: "uint88", name: "extensionFee", type: "uint88" }
-            ],
-            stateMutability: "view",
-            type: "function"
-          }
-        ];
-        const contract = new ethers.Contract(this.termManagerAddress, abi, provider);
-        const result = await contract.getTermFees(termMonths);
-        return {
-          originationFeeBps: Number(result.originationFee?.toString?.() ?? result[0]?.toString?.() ?? result[0]),
-          extensionFeeBps: Number(result.extensionFee?.toString?.() ?? result[1]?.toString?.() ?? result[1])
-        };
-      } catch (error) {
-        console.error(
-          "[ProtocolParameters] Error fetching term fees:",
-          error.message
-        );
-        throw new Error(`Failed to fetch term fees: ${error.message}`);
-      }
-    }
-  };
-  function createProtocolParametersModule(config) {
-    return new ProtocolParametersModule(config);
-  }
-
-  // src/modules/vault-snapshot.ts
-  var VaultSnapshotModule = class {
-    constructor(config) {
-      this.config = config;
-    }
-    /**
-     * Get complete vault snapshot
-     *
-     * This is the main entry point. Returns everything you need to know
-     * about a vault's health in a single call.
-     *
-     * @param positionId - Position to snapshot
-     * @returns Complete VaultSnapshot with all metrics
-     */
-    async getVaultSnapshot(positionId) {
-      const positionState = await this.queryPositionState(positionId);
-      console.log(`[Vault Snapshot] Raw vault address from contract: "${positionState.vaultAddress}"`);
-      const balanceResult = await this.config.vaultBalance.calculateTrustedBalance(
-        positionId,
-        positionState.vaultAddress
-      );
-      const btcPriceUsd = await this.config.priceOracle.getBTCPrice();
-      const protocolParams = createProtocolParametersModule({
-        termManagerAddress: this.config.termManagerAddress,
-        loanOpsManagerAddress: this.config.loanOpsManagerAddress,
-        chain: this.config.chain
-      });
-      const [liquidationThresholdBps, termFees] = await Promise.all([
-        protocolParams.getLiquidationThreshold(),
-        protocolParams.getTermFees(positionState.selectedTerm)
-      ]);
-      const termStatus = calculateTermStatus(
-        positionState.termStartTimestamp,
-        positionState.selectedTerm
-      );
-      const currentLiquidationThreshold = calculateLiquidationThreshold(
-        termStatus.isExpired,
-        termStatus.daysIntoGracePeriod
-      );
-      const collateralMetrics = calculateCollateralMetrics(
-        balanceResult.availableBalance,
-        btcPriceUsd,
-        positionState.ucdDebt
-      );
-      const isLiquidatable = collateralMetrics.collateralRatioBps < currentLiquidationThreshold;
-      const marginToLiquidationBps = collateralMetrics.collateralRatioBps - currentLiquidationThreshold;
-      return {
-        // Raw state
-        positionId: positionState.positionId,
-        pkpId: positionState.pkpId,
-        borrower: positionState.borrower,
-        vaultAddress: positionState.vaultAddress,
-        ucdDebt: positionState.ucdDebt,
-        termStartTimestamp: positionState.termStartTimestamp,
-        selectedTerm: positionState.selectedTerm,
-        isActive: positionState.isActive,
-        status: positionState.status,
-        // Loan status enum value (0-7)
-        // Bitcoin state
-        totalBTCSats: balanceResult.totalBalance,
-        totalUTXOs: balanceResult.totalUTXOs,
-        authorizedSpendsSats: balanceResult.authorizedBalance,
-        availableBTCSats: balanceResult.availableBalance,
-        availableUTXOs: balanceResult.availableUTXOs,
-        // Price data
-        btcPriceUsd,
-        // Calculated metrics
-        collateralValueUsd: collateralMetrics.collateralValueUsd,
-        collateralRatioBps: collateralMetrics.collateralRatioBps,
-        // Term status
-        termDurationDays: termStatus.termDurationDays,
-        termLengthDays: termStatus.termLengthDays,
-        isExpired: termStatus.isExpired,
-        daysUntilExpiry: termStatus.daysUntilExpiry,
-        daysIntoGracePeriod: termStatus.daysIntoGracePeriod,
-        // Liquidation risk
-        currentLiquidationThreshold,
-        isLiquidatable,
-        marginToLiquidationBps,
-        // Protocol parameters (from smart contracts)
-        liquidationThresholdBps,
-        originationFeeBps: termFees.originationFeeBps,
-        extensionFeeBps: termFees.extensionFeeBps,
-        // Metadata
-        timestamp: Date.now()
-      };
-    }
-    /**
-     * Query position state from smart contract
-     *
-     * Gets the simple state that contract stores:
-     * - positionId, pkpId, borrower, vaultAddress
-     * - ucdDebt
-     * - termStartTimestamp
-     * - selectedTerm
-     * - isActive
-     * - status
-     */
-    async queryPositionState(positionId) {
-      const positionIdBytes32 = positionId.startsWith("0x") ? positionId : `0x${positionId.padStart(64, "0")}`;
-      const getPositionDetailsABI = [
-        {
-          inputs: [
-            { internalType: "bytes32", name: "positionId", type: "bytes32" }
-          ],
-          name: "getPositionDetails",
-          outputs: [
-            {
-              components: [
-                { internalType: "bytes32", name: "positionId", type: "bytes32" },
-                { internalType: "bytes32", name: "pkpId", type: "bytes32" },
-                { internalType: "uint256", name: "ucdDebt", type: "uint256" },
-                {
-                  internalType: "string",
-                  name: "vaultAddress",
-                  type: "string"
-                },
-                { internalType: "address", name: "borrower", type: "address" },
-                { internalType: "uint40", name: "createdAt", type: "uint40" },
-                { internalType: "uint40", name: "lastUpdated", type: "uint40" },
-                {
-                  internalType: "uint16",
-                  name: "selectedTerm",
-                  type: "uint16"
-                },
-                { internalType: "uint40", name: "expiryAt", type: "uint40" },
-                { internalType: "bool", name: "isActive", type: "bool" },
-                {
-                  internalType: "enum LoanStatusLib.LoanStatus",
-                  name: "status",
-                  type: "uint8"
-                }
-              ],
-              internalType: "struct IPositionManagerCore.Position",
-              name: "",
-              type: "tuple"
-            }
-          ],
-          stateMutability: "view",
-          type: "function"
-        }
-      ];
-      let rpcUrl;
-      if (this.config.rpcUrl) {
-        rpcUrl = this.config.rpcUrl;
-      } else {
-        rpcUrl = await Lit.Actions.getRpcUrl({ chain: this.config.chain });
-      }
-      const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
-      const contract = new ethers.Contract(
-        this.config.contractAddress,
-        getPositionDetailsABI,
-        provider
-      );
-      const position = await contract.getPositionDetails(positionIdBytes32);
-      const expiryAt = Number(position.expiryAt);
-      const selectedTermMonths = Number(position.selectedTerm);
-      const termStartTimestamp = calculateTermStartFromExpiry(
-        expiryAt,
-        selectedTermMonths
-      );
-      return {
-        positionId: position.positionId,
-        pkpId: position.pkpId,
-        borrower: position.borrower,
-        vaultAddress: this.parseVaultAddress(
-          position.vaultAddress,
-          validateChain(this.config.chain)
-        ),
-        ucdDebt: BigInt(position.ucdDebt.toString()),
-        termStartTimestamp,
-        selectedTerm: selectedTermMonths,
-        isActive: position.isActive,
-        status: Number(position.status)
-        // Extract loan status enum value (0-7)
-      };
-    }
-    /**
-     * Parse vault address based on format and network
-     *
-     * Supports two formats:
-     * 1. Single string: "mqM3ZR2N6DzZkafSdFqxEAkWovAU3uYTAN"
-     * 2. JSON object: {"mainnet":"bc1q...","testnet":"mqM3ZR2N6DzZkafSdFqxEAkWovAU3uYTAN"}
-     *
-     * @param rawVaultAddress Raw vault address from contract
-     * @param chain EVM chain (sepolia, ethereum)
-     * @returns Parsed Bitcoin address for the appropriate network
-     */
-    parseVaultAddress(rawVaultAddress, chain) {
-      try {
-        const parsed = JSON.parse(rawVaultAddress);
-        if (typeof parsed === "object" && parsed !== null) {
-          const chainLower = chain.toLowerCase();
-          if (chainLower === "sepolia") {
-            return parsed.regtest || parsed.testnet || parsed.mainnet;
-          }
-          const bitcoinNetwork = getBitcoinNetworkForChain(chain);
-          if (bitcoinNetwork === "testnet" /* TESTNET */) {
-            return parsed.testnet || parsed.regtest || parsed.mainnet;
-          } else {
-            return parsed.mainnet;
-          }
-        }
-      } catch (e) {
-      }
-      return rawVaultAddress;
-    }
-    /**
-     * Quick check if position is liquidatable
-     *
-     * Convenience method when you only need to know if position can be liquidated.
-     *
-     * @param positionId - Position to check
-     * @returns True if position is liquidatable
-     */
-    async isLiquidatable(positionId) {
-      const snapshot = await this.getVaultSnapshot(positionId);
-      return snapshot.isLiquidatable;
-    }
-    /**
-     * Get collateral ratio for position
-     *
-     * Convenience method when you only need the collateral ratio.
-     *
-     * @param positionId - Position to check
-     * @returns Collateral ratio in basis points
-     */
-    async getCollateralRatio(positionId) {
-      const snapshot = await this.getVaultSnapshot(positionId);
-      return snapshot.collateralRatioBps;
-    }
-    /**
-     * Get available BTC balance
-     *
-     * Convenience method when you only need available balance.
-     *
-     * @param positionId - Position to check
-     * @returns Available BTC in satoshis
-     */
-    async getAvailableBalance(positionId) {
-      const snapshot = await this.getVaultSnapshot(positionId);
-      return snapshot.availableBTCSats;
-    }
-    /**
-     * Check if position has sufficient collateral for new debt
-     *
-     * Used by minting authorization to validate new mints.
-     *
-     * @param positionId - Position to check
-     * @param additionalDebt - Additional UCD debt to add
-     * @param requiredRatioBps - Required collateral ratio (e.g., 13000 for 130%)
-     * @returns True if sufficient collateral exists
-     */
-    async hasSufficientCollateral(positionId, additionalDebt, requiredRatioBps) {
-      const snapshot = await this.getVaultSnapshot(positionId);
-      return hasSufficientCollateralForDebt(
-        snapshot.collateralValueUsd,
-        snapshot.ucdDebt,
-        additionalDebt,
-        requiredRatioBps
-      );
-    }
-  };
-  function createVaultSnapshotModule(config) {
-    return new VaultSnapshotModule(config);
-  }
-
-  // src/btc-deposit-validator.ts
-  var go = async () => {
-    const MIN_BTC_PRICE_USD = 1000000000000n;
-    const MAX_BTC_PRICE_USD = 100000000000000n;
-    console.log("[BTC Deposit Validator] Starting validation...");
-    const { auth, publicKey, chain, bitcoinProviderUrl } = globalThis;
-    if (!auth || typeof auth !== "object") throw new Error("auth is required");
-    if (!auth.positionId) throw new Error("auth.positionId is required");
-    if (!auth.callerAddress) throw new Error("auth.callerAddress is required");
-    if (typeof auth.timestamp !== "number") throw new Error("auth.timestamp must be number");
-    if (!publicKey || typeof publicKey !== "string") throw new Error("publicKey is required");
-    if (!chain || typeof chain !== "string") throw new Error("chain is required");
-    console.log(`  Chain: ${chain}`);
-    validateChain(chain);
-    let POSITION_MANAGER_ADDRESS = "";
-    let TERM_MANAGER_ADDRESS = "";
-    let LOAN_OPS_MANAGER_ADDRESS = "";
-    let bitcoinProviderConfig;
-    if (!globalThis.signOnly) {
-      const networkConfig = getNetworkConfig(chain);
-      POSITION_MANAGER_ADDRESS = networkConfig.contracts.PositionManager;
-      TERM_MANAGER_ADDRESS = networkConfig.contracts.TermManagerModule;
-      LOAN_OPS_MANAGER_ADDRESS = networkConfig.contracts.LoanOperationsManagerModule;
-      bitcoinProviderConfig = getBitcoinProviderConfig(chain, bitcoinProviderUrl);
-      console.log(`  Bitcoin network: ${bitcoinProviderConfig.network}`);
-      console.log(`  Min confirmations: ${bitcoinProviderConfig.minConfirmations}`);
-    } else {
-      console.log("  signOnly=true \u2192 skipping network and contract initialization");
-    }
-    let vaultBalanceSats = 0n;
-    let priceOracle;
-    if (!globalThis.signOnly) {
-      console.log("[Step 1] Initializing Bitcoin data provider...");
-      const bitcoinProvider = new BitcoinDataProvider({
-        providerUrl: bitcoinProviderConfig.url
-      });
-      priceOracle = new PriceOracleModule({ mode: globalThis.disablePriceCheck ? "fast" : "fast" });
-      const vaultBalance = createVaultBalanceModule({
-        contractAddress: LOAN_OPS_MANAGER_ADDRESS,
-        chain,
-        bitcoinProvider,
-        minConfirmations: bitcoinProviderConfig.minConfirmations
-      });
-      console.log("[Step 2] Getting vault snapshot...");
-      const vaultSnapshot = createVaultSnapshotModule({
-        contractAddress: POSITION_MANAGER_ADDRESS,
-        termManagerAddress: TERM_MANAGER_ADDRESS,
-        loanOpsManagerAddress: LOAN_OPS_MANAGER_ADDRESS,
-        chain,
-        vaultBalance,
-        priceOracle
-      });
-      const snapshot = await vaultSnapshot.getVaultSnapshot(auth.positionId);
-      vaultBalanceSats = snapshot.availableBTCSats;
-      if (globalThis.disablePriceCheck) {
-        console.log("[Step 3] Skipping BTC price validation (disablePriceCheck=true)");
-      } else {
-        console.log("[Step 3] Validating BTC price...");
-        if (snapshot.btcPriceUsd < MIN_BTC_PRICE_USD || snapshot.btcPriceUsd > MAX_BTC_PRICE_USD) {
-          throw new Error(
-            `Bitcoin price ${snapshot.btcPriceUsd} is outside acceptable range (${MIN_BTC_PRICE_USD} - ${MAX_BTC_PRICE_USD}). This may indicate oracle manipulation or stale price data. Please try again later.`
-          );
-        }
-      }
-      console.log(`  \u2705 BTC price validation passed or skipped`);
-      console.log(`  Vault balance: ${vaultBalanceSats} sats`);
-    } else {
-      const override = globalThis.vaultBalanceOverride;
-      vaultBalanceSats = override ? BigInt(override) : 1n;
-      console.log(`[signOnly] Using vaultBalanceSats=${vaultBalanceSats.toString()} for message`);
-    }
-    console.log("[Step 3a] Validating BTC amount bounds...");
-    if (vaultBalanceSats > MAX_BTC_AMOUNT) {
-      throw new Error(
-        `BTC amount ${vaultBalanceSats} exceeds maximum allowed ${MAX_BTC_AMOUNT}. This may indicate corrupted data or malicious oracle manipulation.`
-      );
-    }
-    console.log(`  \u2705 BTC amount within bounds (max: ${MAX_BTC_AMOUNT} sats)`);
-    if (!globalThis.signOnly && vaultBalanceSats === 0n) {
-      console.log("  \u2139\uFE0F  No balance detected in vault");
-      Lit.Actions.setResponse({
-        response: JSON.stringify({
-          ok: true,
-          hasBalance: false,
-          vaultBalance: "0",
-          positionId: auth.positionId,
-          callerAddress: auth.callerAddress,
-          timestamp: auth.timestamp,
-          validatorPkp: publicKey
-        })
-      });
-      return;
-    }
-    if (!globalThis.signOnly) {
-      console.log(`  \u2705 Vault has balance: ${vaultBalanceSats} sats`);
-    } else {
-      console.log(`  \u2705 signOnly: proceeding to sign without balance check`);
-    }
-    console.log("[Step 5] Building authorization message...");
-    const message = ethers.utils.keccak256(
-      // @ts-ignore - ethers is provided in the LIT runtime
-      ethers.utils.defaultAbiCoder.encode(
-        ["bytes32", "uint256", "uint256", "address"],
-        [
-          auth.positionId,
-          vaultBalanceSats.toString(),
-          auth.timestamp,
-          auth.callerAddress
-        ]
-      )
-    );
-    console.log("[Step 6] Signing authorization...");
-    console.log("  \u{1F510} PKP Signing Parameters:");
-    console.log("     publicKey:", publicKey);
-    console.log("     message hash:", message);
-    console.log("     message length:", message.length);
-    console.log("     sigName: depositAuth");
-    try {
-      const signatureStartTime = Date.now();
-      console.log("  \u23F1\uFE0F  Starting Lit.Actions.signEcdsa() call...");
-      let signature;
-      try {
-        signature = await Lit.Actions.signEcdsa({
-          // @ts-ignore - ethers is provided in the LIT runtime
-          toSign: ethers.utils.arrayify(message),
-          publicKey,
-          sigName: "depositAuth"
-        });
-      } catch (e) {
-        Lit.Actions.setResponse({
-          response: JSON.stringify({
-            ok: false,
-            error: `Signing failed: ${e?.message || String(e)}`,
-            positionId: auth.positionId,
-            timestamp: auth.timestamp
-          })
-        });
-        return;
-      }
-      const signatureDuration = Date.now() - signatureStartTime;
-      console.log(`  \u2705 Lit.Actions.signEcdsa() completed in ${signatureDuration}ms`);
-      console.log("  \u{1F4DD} Signature result:", JSON.stringify(signature, null, 2));
-      console.log("[BTC Deposit Validator] \u2705 Complete");
-      Lit.Actions.setResponse({
-        response: JSON.stringify({
-          ok: true,
-          hasBalance: !globalThis.signOnly ? true : void 0,
-          message,
-          signature,
-          vaultBalance: vaultBalanceSats.toString(),
-          positionId: auth.positionId,
-          callerAddress: auth.callerAddress,
-          timestamp: auth.timestamp,
-          validatorPkp: publicKey,
-          // btcPriceUsd omitted in signOnly mode
-          ...priceOracle ? { btcPriceUsd: void 0 } : {}
-        })
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error("  \u274C PKP signing failed:", errorMessage);
-      console.error("  Error details:", error);
-      Lit.Actions.setResponse({
-        response: JSON.stringify({
-          ok: false,
-          error: `PKP signing failed: ${errorMessage}`,
-          positionId: auth.positionId,
-          callerAddress: auth.callerAddress,
-          timestamp: auth.timestamp,
-          validatorPkp: publicKey
-        })
-      });
-    }
-  };
-  go();
-})();