@gvnrdao/dh-lit-actions 0.0.28 → 0.0.29

package/out/ucd-mint-validator.hash

@@ -1 +1 @@
-5cf86424936e8691f73e6ff8b9a905da15de40ef883495b9cfe79becaaee2c95
+e8e09a379fce1f039c3cd593d07b5bade9acb509d4ef93aec46a2a4dda27f346

package/out/ucd-mint-validator.js

@@ -11,10 +11,6 @@ var _LIT_ACTION_ = (() => {
   var PRICE_ORACLE_DECIMALS = 100000000n;
   var UCD_TOKEN_DECIMALS = 1000000000000000000n;
 
-  // src/constants/chunks/price-oracle.ts
-  var PRICE_ORACLE_OUTLIER_DEVIATION_THRESHOLD = 0.02;
-  var PRICE_ORACLE_DISPERSION_THRESHOLD = 0.05;
-
   // src/constants/chunks/bitcoin.ts
   var BITCOIN_DEFAULT_MIN_CONFIRMATIONS = 6;
 
@@ -230,43 +226,6 @@ var _LIT_ACTION_ = (() => {
   function getQuantumStart(timestamp) {
     return Math.floor(timestamp / QUANTUM_WINDOW_SECONDS) * QUANTUM_WINDOW_SECONDS;
   }
-  function getCurrentQuantumTimestamp() {
-    const now = Math.floor(Date.now() / 1e3);
-    return getQuantumStart(now);
-  }
-  function isInDeadZone(now) {
-    const currentTime = now ?? Math.floor(Date.now() / 1e3);
-    const timeInQuantum = currentTime % QUANTUM_WINDOW_SECONDS;
-    return timeInQuantum >= 92 || timeInQuantum < 8;
-  }
-  async function waitForSafeQuantumMoment() {
-    const now = Math.floor(Date.now() / 1e3);
-    const timeInQuantum = now % QUANTUM_WINDOW_SECONDS;
-    if (!isInDeadZone(now)) {
-      return;
-    }
-    let waitSeconds;
-    if (timeInQuantum >= 92) {
-      waitSeconds = 100 - timeInQuantum + 8;
-    } else {
-      waitSeconds = 8 - timeInQuantum;
-    }
-    console.log(
-      `[Quantum] Waiting ${waitSeconds}s for safe moment (current time in quantum: ${timeInQuantum}s)`
-    );
-    await new Promise((resolve) => setTimeout(resolve, waitSeconds * 1e3));
-    console.log(`[Quantum] Safe quantum ready: ${getCurrentQuantumTimestamp()}`);
-  }
-  function validateQuantumTimestamp(timestampOnSignature, now) {
-    const currentTime = now ?? Math.floor(Date.now() / 1e3);
-    const currentQuantum = getQuantumStart(currentTime);
-    const signatureQuantum = getQuantumStart(timestampOnSignature);
-    if (signatureQuantum !== currentQuantum) {
-      throw new Error(
-        `[Quantum] Invalid timestamp: signature from quantum ${signatureQuantum}, current quantum is ${currentQuantum}`
-      );
-    }
-  }
 
   // src/modules/authorization.module.ts
   var AuthorizationModule = class {
@@ -287,9 +246,26 @@ var _LIT_ACTION_ = (() => {
      * @returns True if authorized
      */
     static async verifyOwnerSignature(litActionName, auth, expectedOwner, actionParams) {
-      await waitForSafeQuantumMoment();
       try {
-        validateQuantumTimestamp(auth.timestamp);
+        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:",
@@ -413,7 +389,11 @@ var _LIT_ACTION_ = (() => {
         positionOwner,
         {
           action: ethers.utils.keccak256(ethers.utils.toUtf8Bytes("mintUCD")),
-          amount: ethers.utils.hexZeroPad(ethers.utils.hexlify(amount), 32)
+          // 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
+          )
         }
       );
     }
@@ -475,7 +455,9 @@ var _LIT_ACTION_ = (() => {
      * @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);
       }
@@ -627,6 +609,7 @@ var _LIT_ACTION_ = (() => {
           );
         }
         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 {
@@ -740,6 +723,23 @@ var _LIT_ACTION_ = (() => {
       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 id = setTimeout(() => controller.abort(), 8e3);
+        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",
@@ -747,12 +747,11 @@ var _LIT_ACTION_ = (() => {
             const url = new URL("https://api.coingecko.com/api/v3/simple/price");
             url.searchParams.set("ids", "bitcoin");
             url.searchParams.set("vs_currencies", "usd");
-            const response = await fetch(url.toString());
-            if (!response.ok) {
-              throw new Error(`CoinGecko API error: ${response.status} ${response.statusText}`);
+            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");
             }
-            const data = await response.json();
-            const price = data.bitcoin.usd;
             const allPrices = await Lit.Actions.broadcastAndCollect({
               name: "coinGeckoPrice",
               value: price.toString()
@@ -768,12 +767,11 @@ var _LIT_ACTION_ = (() => {
           fetchPrice: async () => {
             const url = new URL("https://api.binance.com/api/v3/ticker/price");
             url.searchParams.set("symbol", "BTCUSDT");
-            const response = await fetch(url.toString());
-            if (!response.ok) {
-              throw new Error(`Binance API error: ${response.status} ${response.statusText}`);
+            const data = await fetchJson(url.toString());
+            const price = Number(data?.price);
+            if (!Number.isFinite(price) || price <= 0) {
+              throw new Error("Invalid Binance price payload");
             }
-            const data = await response.json();
-            const price = parseFloat(data.price);
             const allPrices = await Lit.Actions.broadcastAndCollect({
               name: "binancePrice",
               value: price.toString()
@@ -787,12 +785,11 @@ var _LIT_ACTION_ = (() => {
         {
           name: "Coinbase",
           fetchPrice: async () => {
-            const response = await fetch("https://api.coinbase.com/v2/prices/BTC-USD/spot");
-            if (!response.ok) {
-              throw new Error(`Coinbase API error: ${response.status} ${response.statusText}`);
+            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");
             }
-            const data = await response.json();
-            const price = parseFloat(data.data.amount);
             const allPrices = await Lit.Actions.broadcastAndCollect({
               name: "coinbasePrice",
               value: price.toString()
@@ -850,6 +847,8 @@ var _LIT_ACTION_ = (() => {
      */
     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();
@@ -874,9 +873,9 @@ var _LIT_ACTION_ = (() => {
       const dispersionRatio = maxPrice / minPrice;
       const validPrices = successful.filter((s) => {
         const deviation = Math.abs(s.price - initialMedian) / initialMedian;
-        return deviation <= PRICE_ORACLE_OUTLIER_DEVIATION_THRESHOLD;
+        return deviation <= OUTLIER_DEVIATION;
       });
-      if (dispersionRatio > 1 + PRICE_ORACLE_DISPERSION_THRESHOLD && validPrices.length === successful.length) {
+      if (dispersionRatio > 1 + DISPERSION_THRESHOLD && validPrices.length === successful.length) {
         throw new Error(
           `Price consensus failed: sources too dispersed (${((dispersionRatio - 1) * 100).toFixed(1)}% spread)`
         );
@@ -1262,24 +1261,21 @@ var _LIT_ACTION_ = (() => {
      * @returns Liquidation threshold in basis points
      */
     async getLiquidationThreshold() {
-      const abi = [
-        {
-          inputs: [],
-          name: "liquidationThreshold",
-          outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-          stateMutability: "view",
-          type: "function"
-        }
-      ];
       try {
-        const result = await Lit.Actions.call({
-          chain: this.chain,
-          contractAddress: this.loanOpsManagerAddress,
-          abi,
-          methodName: "liquidationThreshold",
-          params: []
-        });
-        return Number(result);
+        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:",
@@ -1297,31 +1293,28 @@ var _LIT_ACTION_ = (() => {
      * @returns Term fees (origination and extension) in basis points
      */
     async getTermFees(termMonths) {
-      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"
-        }
-      ];
       try {
-        const result = await Lit.Actions.call({
-          chain: this.chain,
-          contractAddress: this.termManagerAddress,
-          abi,
-          methodName: "getTermFees",
-          params: [termMonths]
-        });
+        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[0]),
-          extensionFeeBps: Number(result[1])
+          originationFeeBps: Number(result.originationFee?.toString?.() ?? result[0]?.toString?.() ?? result[0]),
+          extensionFeeBps: Number(result.extensionFee?.toString?.() ?? result[1]?.toString?.() ?? result[1])
         };
       } catch (error) {
         console.error(
@@ -1352,6 +1345,7 @@ var _LIT_ACTION_ = (() => {
      */
     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
@@ -2109,6 +2103,7 @@ var _LIT_ACTION_ = (() => {
             "bytes32",
             "bytes32",
             "bytes32",
+            "bytes32",
             "uint256"
           ],
           [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gvnrdao/dh-lit-actions",
-  "version": "0.0.28",
+  "version": "0.0.29",
   "type": "module",
   "description": "Diamond Hands Protocol LIT Actions - Deterministic, Auditable Builds",
   "main": "./pkg-dist/index.cjs",