@gvnrdao/dh-lit-actions 0.0.32 → 0.0.34

package/out/ucd-mint-validator.js

@@ -1,2203 +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/loan-status.ts
-  function loanStatusToString(status) {
-    switch (status) {
-      case 0 /* PENDING_DEPOSIT */:
-        return "PENDING_DEPOSIT";
-      case 1 /* PENDING_MINT */:
-        return "PENDING_MINT";
-      case 2 /* ACTIVE */:
-        return "ACTIVE";
-      case 3 /* EXPIRED */:
-        return "EXPIRED";
-      case 4 /* LIQUIDATABLE */:
-        return "LIQUIDATABLE";
-      case 5 /* LIQUIDATED */:
-        return "LIQUIDATED";
-      case 6 /* REPAID */:
-        return "REPAID";
-      case 7 /* CLOSED */:
-        return "CLOSED";
-      default:
-        return `UNKNOWN(${status})`;
-    }
-  }
-  function getValidMintingStatuses() {
-    return [
-      0 /* PENDING_DEPOSIT */,
-      1 /* PENDING_MINT */,
-      2 /* ACTIVE */
-    ];
-  }
-
-  // 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/quantum-time.module.ts
-  function getQuantumStart(timestamp) {
-    return Math.floor(timestamp / QUANTUM_WINDOW_SECONDS) * QUANTUM_WINDOW_SECONDS;
-  }
-
-  // src/modules/authorization.module.ts
-  var AuthorizationModule = class {
-    /**
-     * Verify owner signature for position action
-     *
-     * Validates that:
-     * 1. Waits for safe quantum moment (if in dead zone)
-     * 2. Timestamp is within valid quantum window
-     * 3. Message includes: LIT action name, caller address, position, timestamp, params
-     * 4. Recovered signer matches claimed caller address
-     * 5. Caller address matches expected owner
-     *
-     * @param litActionName - Name of the LIT action (e.g., "ucd-mint-validator")
-     * @param auth - Authorization parameters
-     * @param expectedOwner - Expected owner address from contract
-     * @param actionParams - Action-specific parameters to include in message
-     * @returns True if authorized
-     */
-    static async verifyOwnerSignature(litActionName, auth, expectedOwner, actionParams) {
-      try {
-        const now = Math.floor(Date.now() / 1e3);
-        const currentQuantum = getQuantumStart(now);
-        const signatureQuantum = getQuantumStart(auth.timestamp);
-        const previousQuantum = currentQuantum - QUANTUM_WINDOW_SECONDS;
-        const previousQuantum2 = previousQuantum - QUANTUM_WINDOW_SECONDS;
-        if (signatureQuantum !== currentQuantum && signatureQuantum !== previousQuantum && signatureQuantum !== previousQuantum2) {
-          console.error(
-            "[Authorization] Quantum timestamp outside allowed window:",
-            `
-  Signature quantum: ${signatureQuantum}`,
-            `
-  Current quantum: ${currentQuantum}`,
-            `
-  Previous quantum: ${previousQuantum}`,
-            `
-  Previous-2 quantum: ${previousQuantum2}`
-          );
-          return false;
-        }
-      } catch (error) {
-        console.error(
-          "[Authorization] Quantum timestamp validation failed:",
-          error
-        );
-        return false;
-      }
-      const message = this.buildAuthorizationMessage(
-        litActionName,
-        auth.callerAddress,
-        auth.positionId,
-        auth.timestamp,
-        actionParams
-      );
-      let recoveredAddress;
-      try {
-        recoveredAddress = await this.recoverSigner(message, auth.signature);
-      } catch (error) {
-        console.error("[Authorization] Signature recovery failed:", error);
-        return false;
-      }
-      if (recoveredAddress.toLowerCase() !== auth.callerAddress.toLowerCase()) {
-        console.error(
-          `[Authorization] Caller address mismatch:`,
-          `
-  Claimed: ${auth.callerAddress}`,
-          `
-  Recovered: ${recoveredAddress}`
-        );
-        return false;
-      }
-      const isAuthorized = auth.callerAddress.toLowerCase() === expectedOwner.toLowerCase();
-      if (!isAuthorized) {
-        console.error(
-          `[Authorization] Not authorized:`,
-          `
-  Caller: ${auth.callerAddress}`,
-          `
-  Owner: ${expectedOwner}`
-        );
-      }
-      return isAuthorized;
-    }
-    /**
-     * Build authorization message for signing
-     *
-     * Creates deterministic message from parameters for signature verification.
-     *
-     * Message structure:
-     * keccak256(litActionName, callerAddress, positionId, timestamp, actionParams...)
-     *
-     * @param litActionName - Name of the LIT action
-     * @param callerAddress - Ethereum address of caller
-     * @param positionId - Position identifier
-     * @param timestamp - Quantum timestamp
-     * @param actionParams - Action-specific parameters
-     * @returns Message hash for signing
-     */
-    static buildAuthorizationMessage(litActionName, callerAddress, positionId, timestamp, actionParams) {
-      const sortedKeys = Object.keys(actionParams).sort();
-      const values = sortedKeys.map((key) => actionParams[key]);
-      const types = [
-        "string",
-        // litActionName
-        "address",
-        // callerAddress
-        "bytes32",
-        // positionId
-        "uint256",
-        // timestamp
-        ...sortedKeys.map(() => "bytes32")
-        // action params
-      ];
-      const allValues = [
-        litActionName,
-        callerAddress,
-        positionId,
-        timestamp,
-        ...values
-      ];
-      const messageHash = ethers.utils.solidityKeccak256(types, allValues);
-      return messageHash;
-    }
-    /**
-     * Recover signer address from signature
-     *
-     * Uses EIP-191 standard (Ethereum Signed Message)
-     *
-     * @param messageHash - Keccak256 hash of the message
-     * @param signature - Signature to verify
-     * @returns Recovered signer address
-     */
-    static async recoverSigner(messageHash, signature) {
-      try {
-        const messageHashBytes = ethers.utils.arrayify(messageHash);
-        const prefixedHash = ethers.utils.hashMessage(messageHashBytes);
-        const recoveredAddress = ethers.utils.recoverAddress(
-          prefixedHash,
-          signature
-        );
-        return recoveredAddress;
-      } catch (error) {
-        console.error("[Authorization] Signature recovery failed:", error);
-        throw new Error(
-          `Failed to recover signer: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-    /**
-     * Verify position owner authorization for mintUCD action
-     *
-     * @param auth - Authorization parameters
-     * @param positionOwner - Position owner address from contract
-     * @param amount - UCD amount to mint (in wei)
-     * @returns True if authorized
-     */
-    static async verifyMintAuthorization(auth, positionOwner, amount) {
-      return this.verifyOwnerSignature(
-        "ucd-mint-validator",
-        auth,
-        positionOwner,
-        {
-          action: ethers.utils.keccak256(ethers.utils.toUtf8Bytes("mintUCD")),
-          // Normalize amount to a consistent 32-byte hex for signing regardless of input type
-          amount: ethers.utils.hexZeroPad(
-            ethers.utils.hexlify(ethers.BigNumber.from(amount)),
-            32
-          )
-        }
-      );
-    }
-    /**
-     * Verify position owner authorization for withdrawal action
-     *
-     * @param auth - Authorization parameters
-     * @param positionOwner - Position owner address from contract
-     * @param btcAddress - Bitcoin address to withdraw to
-     * @param satoshis - Amount in satoshis
-     * @returns True if authorized
-     */
-    static async verifyWithdrawalAuthorization(auth, positionOwner, btcAddress, satoshis) {
-      return this.verifyOwnerSignature(
-        "btc-withdrawal-validator",
-        auth,
-        positionOwner,
-        {
-          action: ethers.utils.keccak256(ethers.utils.toUtf8Bytes("withdraw")),
-          btcAddress: ethers.utils.keccak256(
-            ethers.utils.toUtf8Bytes(btcAddress)
-          ),
-          satoshis: ethers.utils.hexZeroPad(ethers.utils.hexlify(satoshis), 32)
-        }
-      );
-    }
-    /**
-     * Verify position owner authorization for repayment action
-     *
-     * @param auth - Authorization parameters
-     * @param positionOwner - Position owner address from contract
-     * @param amount - UCD amount to repay (in wei)
-     * @returns True if authorized
-     */
-    static async verifyRepaymentAuthorization(auth, positionOwner, amount) {
-      return this.verifyOwnerSignature(
-        "ucd-repayment-validator",
-        auth,
-        positionOwner,
-        {
-          action: ethers.utils.keccak256(ethers.utils.toUtf8Bytes("repay")),
-          amount: ethers.utils.hexZeroPad(ethers.utils.hexlify(amount), 32)
-        }
-      );
-    }
-  };
-
-  // 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;
-  }
-  function calculateFeeBps(amount, feeBps) {
-    if (amount < 0n) {
-      throw new Error("Amount cannot be negative");
-    }
-    if (feeBps < 0 || feeBps > 1e4) {
-      throw new Error(
-        "Fee basis points must be between 0 and 10000 (0% to 100%)"
-      );
-    }
-    const fee = amount * BigInt(feeBps) / 10000n;
-    return fee;
-  }
-  function calculateBtcValueUsd(btcSats, btcPriceUsd8Decimals) {
-    if (btcSats < 0n) {
-      throw new Error("BTC amount cannot be negative");
-    }
-    if (btcPriceUsd8Decimals <= 0n) {
-      throw new Error("BTC price must be positive");
-    }
-    const valueUsd = btcSats * btcPriceUsd8Decimals / SATOSHIS_PER_BITCOIN;
-    return valueUsd;
-  }
-  function calculateCollateralRatioBps(collateralValueUsd8Decimals, debtUsd18Decimals) {
-    if (collateralValueUsd8Decimals < 0n) {
-      throw new Error("Collateral value cannot be negative");
-    }
-    if (debtUsd18Decimals <= 0n) {
-      throw new Error("Debt must be positive to calculate ratio");
-    }
-    const scaledCollateral = collateralValueUsd8Decimals * 10000000000n;
-    const ratioBps = scaledCollateral * 10000n / debtUsd18Decimals;
-    const ratioBpsNumber = Number(ratioBps);
-    if (ratioBpsNumber < 0 || ratioBpsNumber > 1e8) {
-      throw new Error(
-        `Collateral ratio out of bounds: ${ratioBpsNumber} bps (${ratioBpsNumber / 100}%)`
-      );
-    }
-    return ratioBpsNumber;
-  }
-  function isCollateralSufficient(collateralValueUsd8Decimals, debtUsd18Decimals, minimumRatioBps) {
-    if (minimumRatioBps < 0 || minimumRatioBps > 1e6) {
-      throw new Error(
-        "Minimum ratio must be between 0 and 1000000 bps (0% to 10000%)"
-      );
-    }
-    const actualRatioBps = calculateCollateralRatioBps(
-      collateralValueUsd8Decimals,
-      debtUsd18Decimals
-    );
-    return actualRatioBps >= minimumRatioBps;
-  }
-  function bpsToPercent(basisPoints) {
-    return basisPoints / 100;
-  }
-
-  // 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/modules/system-health.module.ts
-  var SystemHealthModule = class {
-    /**
-     * Check if contract is paused
-     * @param chain Chain identifier
-     * @param contractAddress Contract address to check
-     * @returns True if contract is paused
-     */
-    static async checkPaused(chain, contractAddress) {
-      const pausedAbi = [{
-        inputs: [],
-        name: "paused",
-        outputs: [{ internalType: "bool", name: "", type: "bool" }],
-        stateMutability: "view",
-        type: "function"
-      }];
-      try {
-        const result = await Lit.Actions.call({
-          chain,
-          contractAddress,
-          abi: pausedAbi,
-          methodName: "paused",
-          params: []
-        });
-        return Boolean(result);
-      } catch (error) {
-        console.error(`Failed to check pause state for ${contractAddress}:`, error);
-        return false;
-      }
-    }
-    /**
-     * Check oracle emergency mode
-     * @param chain Chain identifier
-     * @param contractAddress Price feed contract address
-     * @returns True if oracle is in emergency mode
-     */
-    static async checkOracleEmergency(chain, contractAddress) {
-      const emergencyModeAbi = [{
-        inputs: [],
-        name: "emergencyMode",
-        outputs: [{ internalType: "bool", name: "", type: "bool" }],
-        stateMutability: "view",
-        type: "function"
-      }];
-      try {
-        const result = await Lit.Actions.call({
-          chain,
-          contractAddress,
-          abi: emergencyModeAbi,
-          methodName: "emergencyMode",
-          params: []
-        });
-        return Boolean(result);
-      } catch (error) {
-        console.error(`Failed to check oracle emergency mode for ${contractAddress}:`, error);
-        return false;
-      }
-    }
-    /**
-     * Check circuit breaker status
-     * @param chain Chain identifier
-     * @param contractAddress Circuit breaker contract address
-     * @returns True if circuit breaker is triggered
-     */
-    static async checkCircuitBreaker(chain, contractAddress) {
-      const circuitBreakerAbi = [{
-        inputs: [],
-        name: "isTriggered",
-        outputs: [{ internalType: "bool", name: "", type: "bool" }],
-        stateMutability: "view",
-        type: "function"
-      }];
-      try {
-        const result = await Lit.Actions.call({
-          chain,
-          contractAddress,
-          abi: circuitBreakerAbi,
-          methodName: "isTriggered",
-          params: []
-        });
-        return Boolean(result);
-      } catch (error) {
-        console.error(`Failed to check circuit breaker for ${contractAddress}:`, error);
-        return false;
-      }
-    }
-    /**
-     * Check UCD token transfers paused
-     * @param chain Chain identifier
-     * @param contractAddress UCD token contract address
-     * @returns True if transfers are paused
-     */
-    static async checkTransfersPaused(chain, contractAddress) {
-      const transfersPausedAbi = [{
-        inputs: [],
-        name: "transfersPaused",
-        outputs: [{ internalType: "bool", name: "", type: "bool" }],
-        stateMutability: "view",
-        type: "function"
-      }];
-      try {
-        const result = await Lit.Actions.call({
-          chain,
-          contractAddress,
-          abi: transfersPausedAbi,
-          methodName: "transfersPaused",
-          params: []
-        });
-        return Boolean(result);
-      } catch (error) {
-        console.error(`Failed to check transfers paused for ${contractAddress}:`, error);
-        return false;
-      }
-    }
-  };
-
-  // src/ucd-mint-validator.ts
-  var go = async () => {
-    const MIN_BTC_PRICE_USD = 1000000000000n;
-    const MAX_BTC_PRICE_USD = 100000000000000n;
-    const MAX_TIMESTAMP_AGE_MS = 5 * 60 * 1e3;
-    const ABI_REMAINING_MINT_CAPACITY = [
-      {
-        inputs: [],
-        name: "getRemainingMintCapacity",
-        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-        stateMutability: "view",
-        type: "function"
-      }
-    ];
-    const ABI_MAX_SUPPLY = [
-      {
-        inputs: [],
-        name: "maxSupply",
-        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-        stateMutability: "view",
-        type: "function"
-      }
-    ];
-    const ABI_CURRENT_SUPPLY = [
-      {
-        inputs: [],
-        name: "getCurrentSupply",
-        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-        stateMutability: "view",
-        type: "function"
-      }
-    ];
-    const ABI_MINIMUM_LOAN_VALUE_WEI = [
-      {
-        inputs: [],
-        name: "minimumLoanValueWei",
-        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-        stateMutability: "view",
-        type: "function"
-      }
-    ];
-    const ABI_MAXIMUM_LOAN_VALUE_UCD = [
-      {
-        inputs: [],
-        name: "maximumLoanValueUcd",
-        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-        stateMutability: "view",
-        type: "function"
-      }
-    ];
-    console.log("[Step 0] Validating configuration...");
-    const chain = globalThis.chain;
-    const bitcoinProviderUrl = globalThis.bitcoinProviderUrl;
-    if (!chain) {
-      throw new Error(
-        'Missing required parameter: "chain". Must be "sepolia" or "ethereum"'
-      );
-    }
-    if (!bitcoinProviderUrl) {
-      throw new Error(
-        'Missing required parameter: "bitcoinProviderUrl". Must be an approved Bitcoin RPC provider URL'
-      );
-    }
-    const validatedChain = validateChain(chain);
-    const bitcoinNetwork = getBitcoinNetworkForChain(validatedChain);
-    const bitcoinProviderConfig = getBitcoinProviderConfig(
-      chain,
-      bitcoinProviderUrl
-    );
-    console.log(`  \u2705 Chain: ${chain} (${validatedChain})`);
-    console.log(`  \u2705 Bitcoin Network: ${bitcoinNetwork}`);
-    console.log(
-      `  \u2705 Bitcoin Provider: ${bitcoinProviderConfig.name} (${bitcoinProviderConfig.url})`
-    );
-    console.log(
-      `  \u2705 Min Confirmations: ${bitcoinProviderConfig.minConfirmations}`
-    );
-    const networkConfig = getNetworkConfig(chain);
-    const POSITION_MANAGER_ADDRESS = networkConfig.contracts.PositionManager;
-    const LOAN_OPS_MANAGER_ADDRESS = networkConfig.contracts.LoanOperationsManagerModule;
-    const TERM_MANAGER_ADDRESS = networkConfig.contracts.TermManagerModule;
-    const UCD_CONTROLLER_ADDRESS = networkConfig.contracts.UCDController;
-    console.log(`  \u2705 Contract addresses loaded for ${chain}`);
-    console.log("[Step 0.5] Critical system health checks...");
-    const CIRCUIT_BREAKER_ADDRESS = networkConfig.contracts.CircuitBreakerModule;
-    const PRICE_FEED_ADDRESS = networkConfig.contracts.PriceFeedConsumer;
-    const UCD_TOKEN_ADDRESS = networkConfig.contracts.UCDToken;
-    const ucdControllerPaused = await SystemHealthModule.checkPaused(
-      chain,
-      UCD_CONTROLLER_ADDRESS
-    );
-    if (ucdControllerPaused) {
-      throw new Error(
-        "UCD Controller is paused - minting operations are currently disabled. Contact protocol administrators for more information."
-      );
-    }
-    console.log("  \u2705 UCD Controller is active");
-    const circuitBreakerTriggered = await SystemHealthModule.checkCircuitBreaker(
-      chain,
-      CIRCUIT_BREAKER_ADDRESS
-    );
-    if (circuitBreakerTriggered) {
-      throw new Error(
-        "Circuit breaker has been triggered - protocol operations are halted. This is an emergency safety measure. Contact protocol administrators."
-      );
-    }
-    console.log("  \u2705 Circuit breaker is not triggered");
-    const oracleEmergency = await SystemHealthModule.checkOracleEmergency(
-      chain,
-      PRICE_FEED_ADDRESS
-    );
-    if (oracleEmergency) {
-      throw new Error(
-        "Price oracle is in emergency mode - price feeds are unreliable. Minting operations are temporarily disabled for safety."
-      );
-    }
-    console.log("  \u2705 Price oracle is operational");
-    const transfersPaused = await SystemHealthModule.checkTransfersPaused(
-      chain,
-      UCD_TOKEN_ADDRESS
-    );
-    if (transfersPaused) {
-      console.log("  \u26A0\uFE0F  WARNING: UCD token transfers are currently paused");
-      console.log("  \u26A0\uFE0F  Minting will succeed but tokens cannot be transferred until unpaused");
-      console.log("  \u26A0\uFE0F  Tokens will remain in your position and can be used for debt repayment");
-    }
-    console.log("  \u2705 System health checks complete");
-    const auth = globalThis.auth;
-    if (!auth || typeof auth !== "object") {
-      throw new Error('Missing or invalid "auth" parameter - must be an object');
-    }
-    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 a number");
-    }
-    if (!auth.signature) {
-      throw new Error("auth.signature is required");
-    }
-    const currentTime = Date.now();
-    const timestampThreshold = 1e10;
-    const isTimestampInSeconds = auth.timestamp < timestampThreshold;
-    const timestampMs = isTimestampInSeconds ? auth.timestamp * 1e3 : auth.timestamp;
-    const timestampAge = currentTime - timestampMs;
-    if (timestampAge < 0) {
-      throw new Error(
-        `auth.timestamp is in the future: ${auth.timestamp} ${isTimestampInSeconds ? "(seconds)" : "(milliseconds)"} vs current ${currentTime}ms. This may indicate clock synchronization issues.`
-      );
-    }
-    if (timestampAge > MAX_TIMESTAMP_AGE_MS) {
-      throw new Error(
-        `auth.timestamp is too old: ${Math.round(timestampAge / 1e3)}s ago (max ${Math.round(MAX_TIMESTAMP_AGE_MS / 1e3)}s). Please refresh your authorization and try again.`
-      );
-    }
-    console.log(`  \u2705 Timestamp validation passed (${Math.round(timestampAge / 1e3)}s old, format: ${isTimestampInSeconds ? "seconds" : "milliseconds"})`);
-    if (globalThis.amount === void 0 || globalThis.amount === null) {
-      throw new Error('Missing required parameter: "amount"');
-    }
-    const amount = BigInt(globalThis.amount);
-    if (amount <= 0n) {
-      throw new Error(`Amount must be positive, got: ${amount.toString()} wei`);
-    }
-    console.log("  Fetching protocol mint limits...");
-    const rpcUrl = await Lit.Actions.getRpcUrl({ chain });
-    const provider = new ethers.providers.JsonRpcProvider(rpcUrl);
-    const loanOpsContract = new ethers.Contract(LOAN_OPS_MANAGER_ADDRESS, ABI_MINIMUM_LOAN_VALUE_WEI, provider);
-    const minLoanValueResult = await loanOpsContract.minimumLoanValueWei();
-    const MIN_MINT_AMOUNT = BigInt(minLoanValueResult.toString());
-    const loanOpsContractForMax = new ethers.Contract(LOAN_OPS_MANAGER_ADDRESS, ABI_MAXIMUM_LOAN_VALUE_UCD, provider);
-    const maxLoanValueUcdResult = await loanOpsContractForMax.maximumLoanValueUcd();
-    const maxLoanValueUcd = BigInt(maxLoanValueUcdResult.toString());
-    const MAX_MINT_AMOUNT = maxLoanValueUcd * 1000000000000000000n;
-    console.log(`  \u2705 Protocol limits loaded from LoanOperationsManager`);
-    console.log(`  - Minimum: ${MIN_MINT_AMOUNT.toString()} wei`);
-    console.log(`  - Maximum: ${MAX_MINT_AMOUNT.toString()} wei`);
-    if (amount < MIN_MINT_AMOUNT) {
-      throw new Error(
-        `Amount too small: ${amount.toString()} wei. Minimum: ${MIN_MINT_AMOUNT.toString()} wei`
-      );
-    }
-    if (amount > MAX_MINT_AMOUNT) {
-      throw new Error(
-        `Amount too large: ${amount.toString()} wei. Maximum: ${MAX_MINT_AMOUNT.toString()} wei`
-      );
-    }
-    const publicKey = globalThis.publicKey;
-    if (!publicKey) {
-      throw new Error('Missing required parameter: "publicKey"');
-    }
-    if (typeof publicKey !== "string" || publicKey.length === 0) {
-      throw new Error("Invalid publicKey: must be non-empty string");
-    }
-    let currentStep = "0.5";
-    try {
-      console.log("[UCD Mint Validator] Started");
-      console.log(`  Position: ${auth.positionId}`);
-      console.log(`  Amount: ${amount.toString()} wei`);
-      const bitcoinProvider = new BitcoinDataProvider({
-        providerUrl: bitcoinProviderConfig.url
-      });
-      const priceOracle = new PriceOracleModule();
-      const vaultBalance = createVaultBalanceModule({
-        contractAddress: LOAN_OPS_MANAGER_ADDRESS,
-        chain,
-        bitcoinProvider,
-        minConfirmations: bitcoinProviderConfig.minConfirmations
-      });
-      currentStep = "1";
-      console.log("[Step 1] 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);
-      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: $${(Number(snapshot.btcPriceUsd) / 1e8).toFixed(2)}`);
-      currentStep = "2";
-      console.log("[Step 2] Authenticating caller...");
-      const isAuthorized = await AuthorizationModule.verifyMintAuthorization(
-        auth,
-        snapshot.borrower,
-        // Expected owner from contract
-        amount
-      );
-      if (!isAuthorized) {
-        throw new Error("Caller not authorized");
-      }
-      console.log("  \u2705 Caller authorized");
-      currentStep = "3";
-      console.log("[Step 3] Validating position state...");
-      const validMintingStates = getValidMintingStatuses();
-      if (!validMintingStates.includes(snapshot.status)) {
-        throw new Error(
-          `Invalid position status for minting: ${loanStatusToString(
-            snapshot.status
-          )}. Must be PENDING_DEPOSIT, PENDING_MINT, or ACTIVE. Current status prevents minting operations.`
-        );
-      }
-      console.log(
-        `  \u2705 Position status valid for minting: ${loanStatusToString(
-          snapshot.status
-        )}`
-      );
-      if (snapshot.isExpired) {
-        throw new Error(
-          `Loan term expired ${snapshot.daysIntoGracePeriod} days ago - minting rejected. Must repay or extend term first.`
-        );
-      }
-      if (snapshot.isLiquidatable) {
-        throw new Error(
-          `Position is liquidatable (${bpsToPercent(
-            snapshot.collateralRatioBps
-          )}% < ${bpsToPercent(
-            snapshot.currentLiquidationThreshold
-          )}%) - minting rejected. Add collateral first.`
-        );
-      }
-      console.log("  \u2705 Position is healthy");
-      console.log(`  - Term: ${snapshot.daysUntilExpiry} days remaining`);
-      console.log(
-        `  - Current ratio: ${bpsToPercent(snapshot.collateralRatioBps)}%`
-      );
-      console.log(
-        `  - Liquidation threshold: ${bpsToPercent(
-          snapshot.currentLiquidationThreshold
-        )}%`
-      );
-      currentStep = "4";
-      console.log("[Step 4] Calculating fees...");
-      const mintFee = calculateFeeBps(amount, snapshot.originationFeeBps);
-      console.log(
-        `  Mint fee: ${mintFee.toString()} wei (${bpsToPercent(snapshot.originationFeeBps)}%)`
-      );
-      currentStep = "4a";
-      console.log("[Step 4a] Validating daily mint limit...");
-      const totalMintAmount = amount + mintFee;
-      const ucdControllerContract = new ethers.Contract(UCD_CONTROLLER_ADDRESS, ABI_REMAINING_MINT_CAPACITY, provider);
-      const remainingCapacity = await ucdControllerContract.getRemainingMintCapacity();
-      const remainingCapacityBigInt = BigInt(remainingCapacity.toString());
-      if (totalMintAmount > remainingCapacityBigInt) {
-        throw new Error(
-          `Daily mint limit would be exceeded: attempting to mint ${totalMintAmount.toString()} wei (${amount.toString()} + ${mintFee.toString()} fee), but only ${remainingCapacityBigInt.toString()} wei remaining in daily capacity`
-        );
-      }
-      console.log("  \u2705 Daily mint limit check passed");
-      console.log(
-        `  - Mint amount (with fee): ${totalMintAmount.toString()} wei`
-      );
-      console.log(
-        `  - Remaining capacity: ${remainingCapacityBigInt.toString()} wei`
-      );
-      currentStep = "4b";
-      console.log("[Step 4b] Validating max supply limit...");
-      const ucdControllerMaxSupplyContract = new ethers.Contract(UCD_CONTROLLER_ADDRESS, ABI_MAX_SUPPLY, provider);
-      const maxSupplyResult = await ucdControllerMaxSupplyContract.maxSupply();
-      const maxSupply = BigInt(maxSupplyResult.toString());
-      if (maxSupply > 0n) {
-        const ucdControllerCurrentSupplyContract = new ethers.Contract(UCD_CONTROLLER_ADDRESS, ABI_CURRENT_SUPPLY, provider);
-        const currentSupplyResult = await ucdControllerCurrentSupplyContract.getCurrentSupply();
-        const currentSupply = BigInt(currentSupplyResult.toString());
-        const projectedSupply = currentSupply + totalMintAmount;
-        if (projectedSupply > maxSupply) {
-          throw new Error(
-            `Max supply would be exceeded: minting ${totalMintAmount.toString()} wei (${amount.toString()} + ${mintFee.toString()} fee) would result in total supply of ${projectedSupply.toString()} wei, exceeding max supply of ${maxSupply.toString()} wei`
-          );
-        }
-        console.log("  \u2705 Max supply check passed");
-        console.log(`  - Current supply: ${currentSupply.toString()} wei`);
-        console.log(`  - After mint: ${projectedSupply.toString()} wei`);
-        console.log(`  - Max supply: ${maxSupply.toString()} wei`);
-        console.log(
-          `  - Remaining capacity: ${(maxSupply - currentSupply).toString()} wei`
-        );
-      } else {
-        console.log("  \u2705 Max supply unlimited (not enforced)");
-      }
-      currentStep = "5";
-      console.log("[Step 5] Calculating new state...");
-      const newDebt = snapshot.ucdDebt + amount + mintFee;
-      const newCollateral = snapshot.availableBTCSats;
-      console.log(`  Current debt: ${snapshot.ucdDebt.toString()} wei`);
-      console.log(`  New debt: ${newDebt.toString()} wei`);
-      console.log(`  Available collateral: ${newCollateral.toString()} sats`);
-      currentStep = "6";
-      console.log("[Step 6] Validating collateral ratio after mint...");
-      const collateralValueUsd8Dec = calculateBtcValueUsd(
-        newCollateral,
-        snapshot.btcPriceUsd
-      );
-      const newCollateralRatioBps = calculateCollateralRatioBps(
-        collateralValueUsd8Dec,
-        newDebt
-      );
-      console.log(
-        `  New collateral ratio: ${bpsToPercent(newCollateralRatioBps)}%`
-      );
-      console.log(
-        `  Minimum required: ${bpsToPercent(snapshot.liquidationThresholdBps)}%`
-      );
-      if (!isCollateralSufficient(
-        collateralValueUsd8Dec,
-        newDebt,
-        snapshot.liquidationThresholdBps
-      )) {
-        throw new Error(
-          `Insufficient collateral: ${bpsToPercent(
-            newCollateralRatioBps
-          )}% < ${bpsToPercent(snapshot.liquidationThresholdBps)}%`
-        );
-      }
-      console.log("  \u2705 Sufficient collateral");
-      currentStep = "7";
-      console.log("[Step 7] Building authorization message...");
-      const authorizedSpendsHash = ethers.utils.keccak256(
-        // @ts-ignore - ethers available in LIT runtime
-        ethers.utils.defaultAbiCoder.encode(
-          ["uint256"],
-          // Simplified: just use total authorized amount
-          [snapshot.authorizedSpendsSats]
-        )
-      );
-      const messageParams = {
-        authorizedSpendsHash,
-        btcPrice: snapshot.btcPriceUsd.toString(),
-        mintAmount: amount.toString(),
-        mintFee: mintFee.toString(),
-        newCollateral: newCollateral.toString(),
-        newDebt: newDebt.toString()
-      };
-      const message = ethers.utils.keccak256(
-        // @ts-ignore - ethers available in LIT runtime
-        ethers.utils.defaultAbiCoder.encode(
-          [
-            "bytes32",
-            "bytes32",
-            "bytes32",
-            "bytes32",
-            "bytes32",
-            "bytes32",
-            "bytes32",
-            "uint256"
-          ],
-          [
-            auth.positionId,
-            // @ts-ignore - ethers available in LIT runtime
-            ethers.utils.hexZeroPad(
-              ethers.utils.hexlify(BigInt(messageParams.authorizedSpendsHash)),
-              32
-            ),
-            // @ts-ignore - ethers available in LIT runtime
-            ethers.utils.hexZeroPad(
-              ethers.utils.hexlify(BigInt(messageParams.btcPrice)),
-              32
-            ),
-            // @ts-ignore - ethers available in LIT runtime
-            ethers.utils.hexZeroPad(
-              ethers.utils.hexlify(BigInt(messageParams.mintAmount)),
-              32
-            ),
-            // @ts-ignore - ethers available in LIT runtime
-            ethers.utils.hexZeroPad(
-              ethers.utils.hexlify(BigInt(messageParams.mintFee)),
-              32
-            ),
-            // @ts-ignore - ethers available in LIT runtime
-            ethers.utils.hexZeroPad(
-              ethers.utils.hexlify(BigInt(messageParams.newCollateral)),
-              32
-            ),
-            // @ts-ignore - ethers available in LIT runtime
-            ethers.utils.hexZeroPad(
-              ethers.utils.hexlify(BigInt(messageParams.newDebt)),
-              32
-            ),
-            auth.timestamp
-          ]
-        )
-      );
-      currentStep = "8";
-      console.log("[Step 8] Signing authorization...");
-      const signature = await Lit.Actions.signEcdsa({
-        // @ts-ignore - ethers available in LIT runtime
-        toSign: ethers.utils.arrayify(message),
-        publicKey,
-        sigName: "ucdMintAuth"
-      });
-      console.log("[UCD Mint Validator] \u2705 Complete");
-      Lit.Actions.setResponse({
-        response: JSON.stringify({
-          approved: true,
-          positionId: auth.positionId,
-          mintAmount: amount.toString(),
-          mintFee: mintFee.toString(),
-          newDebt: newDebt.toString(),
-          newCollateral: newCollateral.toString(),
-          newCollateralRatioBps,
-          btcPrice: snapshot.btcPriceUsd.toString(),
-          authorizedSpendsHash,
-          signature,
-          timestamp: auth.timestamp,
-          validatorPkp: publicKey
-        })
-      });
-    } catch (error) {
-      console.error("[UCD Mint Validator] \u274C Failed:", error.message);
-      console.error(`[UCD Mint Validator] Failed at step: ${currentStep}`);
-      Lit.Actions.setResponse({
-        response: JSON.stringify({
-          approved: false,
-          reason: error.message || error.toString(),
-          failedStep: currentStep,
-          positionId: auth?.positionId,
-          timestamp: Date.now()
-        })
-      });
-    }
-  };
-  go();
-})();