@gvnrdao/dh-lit-ops 0.0.201 → 0.0.213

package/dist/modules/lit-ops.module.js

@@ -54,6 +54,7 @@ const pkp_minter_module_1 = require("./pkp-minter.module");
 const pkp_signer_module_1 = require("./pkp-signer.module");
 const session_signature_manager_module_1 = require("./session-signature-manager.module");
 const capacity_master_module_1 = require("./capacity-master.module");
+const pkp_token_id_1 = require("../utils/pkp-token-id");
 class LitOps {
     constructor(config) {
         // CRITICAL VALIDATION: Reject datil-test immediately with terrifying error
@@ -1609,14 +1610,19 @@ class LitOps {
         // Add custom RPC URL for local development (ngrok tunnels)
         if (request.customRpcUrl) {
             litActionParams.customRpcUrl = request.customRpcUrl;
+            // Also set rpcUrl as fallback (some LIT actions expect this)
+            litActionParams.rpcUrl = request.customRpcUrl;
             if (this.config.debug) {
                 console.log("   Custom RPC URL:", request.customRpcUrl);
+                console.log("   Setting both customRpcUrl and rpcUrl parameters");
             }
         }
         // Execute LIT Action (single attempt - retry logic is in SDK layer)
         const result = await this.actionExecutor.executeAction({
             cid: litActionInfo.cid,
             pkpPublicKey: litActionInfo.pkp.publicKey,
+            pkpTokenId: (0, pkp_token_id_1.normalizePkpTokenIdForLitResource)(String(litActionInfo.pkp.tokenId)) ?? String(litActionInfo.pkp.tokenId),
+            pkpEthAddress: litActionInfo.pkp.ethAddress,
             params: litActionParams,
             signer: this.config.signer,
             priceProviders: request.priceProviders, // Pass price provider API keys (standalone mode)
@@ -1894,6 +1900,8 @@ class LitOps {
         const result = await this.actionExecutor.executeAction({
             cid: litActionInfo.cid,
             pkpPublicKey: litActionInfo.pkp.publicKey,
+            pkpTokenId: (0, pkp_token_id_1.normalizePkpTokenIdForLitResource)(String(litActionInfo.pkp.tokenId)) ?? String(litActionInfo.pkp.tokenId),
+            pkpEthAddress: litActionInfo.pkp.ethAddress,
             params: litActionParams,
             signer: this.config.signer,
             priceProviders: request.priceProviders, // Pass price provider API keys (standalone mode)
@@ -1976,6 +1984,240 @@ class LitOps {
         }
         return returnValue;
     }
+    /**
+     * Request extend position authorization (dual-mode)
+     *
+     * In SERVICE mode: Delegates to lit-ops-server HTTP endpoint
+     * In STANDALONE mode: Executes extend-position-validator LIT Action locally
+     *
+     * @param request - Authorization request with authMessage and userSignature
+     * @returns Extend authorization response from LIT Action
+     */
+    async requestExtendAuthorization(request) {
+        if (this.config.debug) {
+            console.log("🔍 [requestExtendAuthorization] Mode check:", this.config.mode);
+        }
+        if (this.config.mode === "service") {
+            if (this.config.debug) {
+                console.log("🌐 [requestExtendAuthorization] Using SERVICE mode - delegating to server");
+            }
+            return this.requestExtendAuthorizationViaService(request);
+        }
+        if (this.config.debug) {
+            console.log("🔧 [requestExtendAuthorization] Using STANDALONE mode - executing locally");
+        }
+        return this.requestExtendAuthorizationStandalone(request);
+    }
+    /**
+     * Request extend authorization via lit-ops-server (SERVICE mode)
+     */
+    async requestExtendAuthorizationViaService(request) {
+        if (!this.config.serviceEndpoint) {
+            throw new Error("Service endpoint not configured for service mode");
+        }
+        const url = `${this.config.serviceEndpoint}/api/lit/extend/authorize`;
+        if (this.config.debug) {
+            console.log("🌐 Requesting extend authorization via service:", url);
+            console.log("   Position ID:", request.authMessage.positionId);
+            console.log("   New Term:", request.authMessage.newTerm);
+        }
+        const requestBody = {
+            authMessage: request.authMessage,
+            userSignature: request.userSignature,
+            customRpcUrl: request.customRpcUrl,
+            customBitcoinRpcUrl: request.customBitcoinRpcUrl,
+            priceProviders: request.priceProviders,
+        };
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 180000); // 3 minutes
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(requestBody),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Service request failed: ${response.status} ${response.statusText} - ${errorText}`);
+            }
+            const serviceResponse = (await response.json());
+            const result = serviceResponse.data || serviceResponse;
+            return {
+                approved: result.approved || false,
+                signature: result.signature,
+                positionId: result.positionId,
+                selectedTerm: result.selectedTerm,
+                btcPrice: result.btcPrice,
+                availableBTCBalance: result.availableBTCBalance,
+                quantumTimestamp: result.quantumTimestamp,
+                extensionFee: result.extensionFee,
+                newTotalDebt: result.newTotalDebt,
+                newCollateralRatioBps: result.newCollateralRatioBps,
+                timestamp: result.timestamp,
+                validatorPkp: result.validatorPkp,
+                reason: result.reason,
+                failedStep: result.failedStep,
+                error: result.error,
+            };
+        }
+        catch (error) {
+            if (this.config.debug) {
+                console.error("❌ Extend authorization service request failed:", error);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Request extend authorization locally (STANDALONE mode)
+     */
+    async requestExtendAuthorizationStandalone(request) {
+        const litActions = this.config.network === "datil"
+            ? dh_lit_actions_1.DH_LIT_ACTIONS_DATIL
+            : (() => {
+                throw new Error("Unsupported LIT network");
+            })();
+        const litActionInfo = litActions.extendPositionValidator;
+        if (this.config.debug) {
+            console.log("🔍 [requestExtendAuthorizationStandalone] Using action:", litActionInfo?.name || "NONE");
+        }
+        if (!litActionInfo || !litActionInfo.cid || !litActionInfo.pkp) {
+            throw new Error("Extend position validator LIT Action not found in registry");
+        }
+        // Debug logging for PKP information
+        console.log("🔥🔥🔥 STANDALONE EXTEND AUTH DEBUG - SERVER IS USING UPDATED CODE 🔥🔥🔥");
+        console.log("🔑 STANDALONE EXTEND AUTH DEBUG - PKP token ID details:");
+        console.log("   Raw from registry:", String(litActionInfo.pkp.tokenId));
+        console.log("   Registry CID:", litActionInfo.cid);
+        console.log("   Registry PKP:", JSON.stringify(litActionInfo.pkp, null, 2));
+        const litClient = await this.clientManager.getClient({
+            litNetwork: this.config.network,
+            debug: this.config.debug,
+        });
+        let chain;
+        let bitcoinProviderUrl;
+        if (request.customBitcoinRpcUrl) {
+            bitcoinProviderUrl = request.customBitcoinRpcUrl;
+            switch (request.authMessage.chainId) {
+                case 1:
+                    chain = "ethereum";
+                    break;
+                case 11155111:
+                    chain = "sepolia";
+                    break;
+                case 1337:
+                case 31337:
+                    chain = "hardhat";
+                    break;
+                default:
+                    throw new Error(`Unsupported chainId: ${request.authMessage.chainId}`);
+            }
+        }
+        else {
+            switch (request.authMessage.chainId) {
+                case 1:
+                    chain = "ethereum";
+                    bitcoinProviderUrl =
+                        process.env.BITCOIN_PROVIDER_URL || "https://mempool.space/api";
+                    break;
+                case 11155111:
+                    chain = "sepolia";
+                    bitcoinProviderUrl =
+                        process.env.BITCOIN_PROVIDER_URL ||
+                            "https://diamond-hands-btc-faucet-6b39a1072059.herokuapp.com/api/esplora";
+                    break;
+                case 1337:
+                case 31337:
+                    chain = "hardhat";
+                    bitcoinProviderUrl =
+                        process.env.BITCOIN_PROVIDER_URL || "http://127.0.0.1:18443";
+                    break;
+                default:
+                    throw new Error(`Unsupported chainId: ${request.authMessage.chainId}`);
+            }
+        }
+        if (request.customBitcoinRpcUrl) {
+            bitcoinProviderUrl = request.customBitcoinRpcUrl;
+        }
+        const auth = {
+            positionId: request.authMessage.positionId,
+            timestamp: request.authMessage.timestamp,
+            chainId: request.authMessage.chainId,
+            newTerm: request.authMessage.newTerm,
+            action: request.authMessage.action,
+            signature: request.userSignature,
+            mode: request.authMessage.mode,
+        };
+        const litActionParams = {
+            chain,
+            bitcoinProviderUrl,
+            auth,
+            selectedTerm: request.authMessage.newTerm,
+            ...(request.authMessage.contractAddresses && {
+                contractAddresses: request.authMessage.contractAddresses,
+            }),
+        };
+        if (request.customRpcUrl) {
+            litActionParams.customRpcUrl = request.customRpcUrl;
+        }
+        const normalizedPkpTokenId = (0, pkp_token_id_1.normalizePkpTokenIdForLitResource)(String(litActionInfo.pkp.tokenId));
+        const finalPkpTokenId = normalizedPkpTokenId ?? String(litActionInfo.pkp.tokenId);
+        console.log("🔥🔥🔥 EXTEND AUTH DEBUG - SERVER IS USING UPDATED CODE 🔥🔥🔥");
+        console.log("🔑 EXTEND AUTH DEBUG - PKP token ID details:");
+        console.log("   Raw from registry:", String(litActionInfo.pkp.tokenId));
+        console.log("   Normalized:", normalizedPkpTokenId);
+        console.log("   Final (passed to executor):", finalPkpTokenId);
+        console.log("   Debug enabled:", this.config.debug);
+        console.log("   Registry CID:", litActionInfo.cid);
+        console.log("   Registry PKP:", JSON.stringify(litActionInfo.pkp, null, 2));
+        const result = await this.actionExecutor.executeAction({
+            cid: litActionInfo.cid,
+            pkpPublicKey: litActionInfo.pkp.publicKey,
+            pkpTokenId: finalPkpTokenId,
+            pkpEthAddress: litActionInfo.pkp.ethAddress,
+            params: litActionParams,
+            signer: this.config.signer,
+            priceProviders: request.priceProviders,
+        }, litClient);
+        let responseData = result.response;
+        if (typeof result.response === "string") {
+            try {
+                responseData = JSON.parse(result.response);
+            }
+            catch (e) {
+                if (this.config.debug) {
+                    console.error("❌ Failed to parse extend response string:", e);
+                }
+            }
+        }
+        const data = responseData;
+        const signatureRaw = result.signatures;
+        const signatureStr = (signatureRaw?.extendPositionAuth?.signature != null
+            ? typeof signatureRaw.extendPositionAuth.signature === "string"
+                ? signatureRaw.extendPositionAuth.signature
+                : JSON.stringify(signatureRaw.extendPositionAuth.signature)
+            : data?.signature);
+        return {
+            approved: data?.approved ?? false,
+            signature: signatureStr,
+            positionId: data?.positionId,
+            selectedTerm: data?.selectedTerm,
+            btcPrice: data?.btcPrice,
+            availableBTCBalance: data?.availableBTCBalance,
+            quantumTimestamp: data?.quantumTimestamp,
+            extensionFee: data?.extensionFee,
+            newTotalDebt: data?.newTotalDebt,
+            newCollateralRatioBps: data?.newCollateralRatioBps,
+            timestamp: data?.timestamp,
+            validatorPkp: data?.validatorPkp,
+            reason: data?.reason,
+            failedStep: data?.failedStep,
+            error: result.error,
+        };
+    }
     /**
      * Request BTC withdrawal authorization (dual-mode)
      *
@@ -1983,12 +2225,26 @@ class LitOps {
      * @returns Withdrawal authorization response from LIT Action
      */
     async requestWithdrawalAuthorization(request) {
-        // In SERVICE mode, delegate to lit-ops-server
+        console.log("🔧 LitOps.requestWithdrawalAuthorization called");
+        console.log("  Config mode:", this.config.mode);
+        console.log("  Config serviceEndpoint:", this.config.serviceEndpoint);
+        console.log("  Position ID:", request.authMessage.positionId);
+        // In SERVICE mode, try server first, fallback to standalone
         if (this.config.mode === "service") {
-            if (this.config.debug) {
-                console.log("🌐 [requestWithdrawalAuthorization] Using SERVICE mode - delegating to server");
+            console.log("🌐 [requestWithdrawalAuthorization] Using SERVICE mode - trying server first");
+            console.log("🌐 Service endpoint:", this.config.serviceEndpoint);
+            try {
+                console.log("🔗 MAKING HTTP CALL TO:", `${this.config.serviceEndpoint}/api/lit/withdraw-btc/authorize`);
+                return await this.requestWithdrawalAuthorizationViaService(request);
+            }
+            catch (serviceError) {
+                console.log("⚠️ Service mode failed, falling back to standalone mode");
+                console.log("⚠️ Service error:", serviceError.message);
+                if (this.config.debug) {
+                    console.log("🔧 [requestWithdrawalAuthorization] FALLBACK: Using STANDALONE mode - executing locally");
+                }
+                return this.requestWithdrawalAuthorizationStandalone(request);
             }
-            return this.requestWithdrawalAuthorizationViaService(request);
         }
         // STANDALONE mode: Execute LIT action locally
         if (this.config.debug) {
@@ -2024,11 +2280,14 @@ class LitOps {
                 bitcoinProviderUrl: request.bitcoinProviderUrl, // Pass to service
                 customRpcUrl: request.customRpcUrl,
                 customBitcoinRpcUrl: request.customBitcoinRpcUrl,
+                ...(request.authMessage.contractAddresses && { contractAddresses: request.authMessage.contractAddresses }),
+                ...(request.priceProviders && { priceProviders: request.priceProviders }),
             };
             if (this.config.debug) {
                 console.log("🔍 [WITHDRAWAL REQUEST] Complete parameters being sent to lit-ops-server:");
                 console.log(JSON.stringify(requestBody, null, 2));
             }
+            console.log("🔗 MAKING HTTP CALL TO:", url);
             const response = await fetch(url, {
                 method: "POST",
                 headers: {
@@ -2040,33 +2299,153 @@ class LitOps {
                 const errorText = await response.text();
                 throw new Error(`Service error (${response.status}): ${errorText}`);
             }
-            const envelope = await response.json();
+            let envelope;
+            try {
+                envelope = await response.json();
+            }
+            catch (parseError) {
+                const errorMsg = parseError instanceof Error ? parseError.message : String(parseError);
+                if (errorMsg.includes("BigNumber") || errorMsg.includes("invalid")) {
+                    console.error("❌ Error parsing JSON response (BigNumber issue):", errorMsg);
+                    return {
+                        approved: false,
+                        error: `LIT Action validation error: ${errorMsg}`,
+                        reason: "Failed to parse service response",
+                    };
+                }
+                throw parseError;
+            }
             if (this.config.debug) {
-                console.log("📥 Service response:", envelope);
+                // Safely log response - avoid accessing properties that might trigger BigNumber errors
+                try {
+                    console.log("📥 Service response:", JSON.stringify(envelope, null, 2));
+                }
+                catch (logError) {
+                    console.log("📥 Service response: [unable to stringify - may contain BigNumber objects]");
+                }
             }
             // Extract data from envelope (server wraps in { success, data } structure)
-            const result = envelope.data || envelope;
-            // Return the result from service
-            return {
-                approved: result.approved ?? false,
-                signature: result.signature,
-                actionHash: result.actionHash,
-                authorizedSpendsHash: result.authorizedSpendsHash,
-                ucdDebtHash: result.ucdDebtHash,
-                contractBundleHash: result.contractBundleHash,
-                totalDeduction: result.totalDeduction,
-                remainingCollateral: result.remainingCollateral,
-                newCollateralRatioBps: result.newCollateralRatioBps,
-                destinationAddress: result.destinationAddress,
-                btcPrice: result.btcPrice,
-                timestamp: result.timestamp,
-                utxoTxid: result.utxoTxid,
-                utxoVout: result.utxoVout,
-                utxoSatoshis: result.utxoSatoshis,
-                reason: result.reason,
-                failedStep: result.failedStep,
-                error: result.error,
+            // Use safe property access to avoid BigNumber errors
+            let result;
+            try {
+                result = envelope.data || envelope;
+            }
+            catch (accessError) {
+                const errorMsg = accessError instanceof Error ? accessError.message : String(accessError);
+                if (errorMsg.includes("BigNumber") || errorMsg.includes("invalid")) {
+                    console.error("❌ Error accessing envelope.data (BigNumber issue):", errorMsg);
+                    return {
+                        approved: false,
+                        error: `LIT Action validation error: ${errorMsg}`,
+                        reason: "Failed to access response data",
+                    };
+                }
+                throw accessError;
+            }
+            // Normalize empty objects to prevent BigNumber errors in SDK
+            // Helper function to safely normalize values - wraps property access in try-catch
+            const safeGetValue = (obj, key) => {
+                try {
+                    return obj?.[key];
+                }
+                catch (e) {
+                    const errorMsg = e instanceof Error ? e.message : String(e);
+                    if (errorMsg.includes("BigNumber") || errorMsg.includes("invalid")) {
+                        if (this.config.debug) {
+                            console.warn(`⚠️ Error accessing ${key} (BigNumber issue), using undefined`);
+                        }
+                        return undefined;
+                    }
+                    throw e;
+                }
             };
+            const normalizeValue = (value, defaultValue) => {
+                if (value === null || value === undefined) {
+                    return defaultValue;
+                }
+                // Check for empty object FIRST - this is the most common issue
+                if (typeof value === "object" && value !== null && Object.keys(value).length === 0) {
+                    return defaultValue;
+                }
+                if (typeof value === "string") {
+                    return value;
+                }
+                if (typeof value === "number") {
+                    return value.toString();
+                }
+                if (typeof value === "bigint") {
+                    return value.toString();
+                }
+                // Try to extract value from object (ethers BigNumber objects)
+                if (typeof value === "object" && value !== null) {
+                    if (value._hex && typeof value._hex === "string" && value._hex.length > 0) {
+                        try {
+                            return ethers_1.ethers.BigNumber.from(value._hex).toString();
+                        }
+                        catch {
+                            return defaultValue;
+                        }
+                    }
+                    if (value.hex && typeof value.hex === "string" && value.hex.length > 0) {
+                        try {
+                            return ethers_1.ethers.BigNumber.from(value.hex).toString();
+                        }
+                        catch {
+                            return defaultValue;
+                        }
+                    }
+                    if (value.value !== undefined) {
+                        return normalizeValue(value.value, defaultValue);
+                    }
+                    if (value.toString && typeof value.toString === "function") {
+                        try {
+                            const str = value.toString();
+                            if (typeof str === "string" && str !== "[object Object]") {
+                                return str;
+                            }
+                        }
+                        catch { }
+                    }
+                    return defaultValue; // Unhandled object
+                }
+                return String(value);
+            };
+            // DEBUG: Log raw result before processing
+            console.log("🔍 LITOPS RAW RESULT ANALYSIS:");
+            console.log("   result type:", typeof result);
+            console.log("   result is object:", typeof result === 'object');
+            console.log("   result keys:", result && typeof result === 'object' ? Object.keys(result) : "N/A");
+            console.log("   raw btcPrice:", safeGetValue(result, "btcPrice"), "type:", typeof safeGetValue(result, "btcPrice"));
+            console.log("   raw btcPrice is empty object:", (() => {
+                const btcPrice = safeGetValue(result, "btcPrice");
+                return btcPrice && typeof btcPrice === 'object' && Object.keys(btcPrice).length === 0;
+            })());
+            // Return the result from service with normalized numeric values
+            // Use safeGetValue to avoid BigNumber errors when accessing properties
+            const processedResult = {
+                approved: safeGetValue(result, "approved") ?? false,
+                signature: safeGetValue(result, "signature"),
+                actionHash: safeGetValue(result, "actionHash"),
+                authorizedSpendsHash: safeGetValue(result, "authorizedSpendsHash"),
+                ucdDebtHash: safeGetValue(result, "ucdDebtHash"),
+                contractBundleHash: safeGetValue(result, "contractBundleHash"),
+                totalDeduction: normalizeValue(safeGetValue(result, "totalDeduction"), "0"),
+                remainingCollateral: normalizeValue(safeGetValue(result, "remainingCollateral"), "0"),
+                newCollateralRatioBps: safeGetValue(result, "newCollateralRatioBps"),
+                destinationAddress: safeGetValue(result, "destinationAddress"),
+                btcPrice: normalizeValue(safeGetValue(result, "btcPrice"), "5000000000000"), // Default: $50,000 with 8 decimals
+                timestamp: normalizeValue(safeGetValue(result, "timestamp"), Math.floor(Date.now() / 1000).toString()),
+                utxoTxid: safeGetValue(result, "utxoTxid"),
+                utxoVout: safeGetValue(result, "utxoVout"),
+                utxoSatoshis: safeGetValue(result, "utxoSatoshis") ? normalizeValue(safeGetValue(result, "utxoSatoshis"), "0") : undefined,
+                reason: safeGetValue(result, "reason"),
+                failedStep: safeGetValue(result, "failedStep"),
+                error: safeGetValue(result, "error"),
+            };
+            console.log("🔍 LITOPS PROCESSED RESULT:");
+            console.log("   processedResult.btcPrice:", processedResult.btcPrice, "type:", typeof processedResult.btcPrice);
+            console.log("   processedResult.btcPrice is empty object:", processedResult.btcPrice && typeof processedResult.btcPrice === 'object' && Object.keys(processedResult.btcPrice).length === 0);
+            return processedResult;
         }
         catch (error) {
             console.error("❌ Service request failed:", error);
@@ -2219,6 +2598,69 @@ class LitOps {
                 }
             }
         }
+        // Normalize empty objects to prevent BigNumber errors in SDK
+        // Helper function to safely normalize values
+        const normalizeValue = (value, defaultValue) => {
+            if (value === null || value === undefined) {
+                return defaultValue;
+            }
+            // Check for empty object FIRST - this is the most common issue
+            if (typeof value === "object" && value !== null && Object.keys(value).length === 0) {
+                return defaultValue;
+            }
+            if (typeof value === "string") {
+                return value;
+            }
+            if (typeof value === "number") {
+                return value.toString();
+            }
+            if (typeof value === "bigint") {
+                return value.toString();
+            }
+            // Try to extract value from object (ethers BigNumber objects)
+            if (typeof value === "object" && value !== null) {
+                if (value._hex && typeof value._hex === "string" && value._hex.length > 0) {
+                    try {
+                        return ethers_1.ethers.BigNumber.from(value._hex).toString();
+                    }
+                    catch {
+                        return defaultValue;
+                    }
+                }
+                if (value.hex && typeof value.hex === "string" && value.hex.length > 0) {
+                    try {
+                        return ethers_1.ethers.BigNumber.from(value.hex).toString();
+                    }
+                    catch {
+                        return defaultValue;
+                    }
+                }
+                if (value.value !== undefined) {
+                    return normalizeValue(value.value, defaultValue);
+                }
+                if (value.toString && typeof value.toString === "function") {
+                    try {
+                        const str = value.toString();
+                        if (typeof str === "string" && str !== "[object Object]") {
+                            return str;
+                        }
+                    }
+                    catch { }
+                }
+                return defaultValue; // Unhandled object
+            }
+            return String(value);
+        };
+        // DEBUG: Log responseData before processing
+        console.log("🔍 STANDALONE RESPONSE DATA ANALYSIS:");
+        console.log("   responseData type:", typeof responseData);
+        console.log("   responseData is object:", typeof responseData === 'object');
+        console.log("   responseData keys:", responseData && typeof responseData === 'object' ? Object.keys(responseData) : "N/A");
+        console.log("   raw responseData.btcPrice:", responseData?.btcPrice, "type:", typeof responseData?.btcPrice);
+        console.log("   raw responseData.btcPrice is empty object:", (() => {
+            const btcPrice = responseData?.btcPrice;
+            return btcPrice && typeof btcPrice === 'object' && Object.keys(btcPrice).length === 0;
+        })());
         // Return standardized response including UTXO data from Bitcoin network query
         const returnValue = {
             approved: responseData?.approved ?? false,
@@ -2229,19 +2671,22 @@ class LitOps {
             authorizedSpendsHash: responseData?.authorizedSpendsHash,
             ucdDebtHash: responseData?.ucdDebtHash,
             contractBundleHash: responseData?.contractBundleHash, // Binds to specific contract deployment
-            totalDeduction: responseData?.totalDeduction,
-            remainingCollateral: responseData?.remainingCollateral,
+            totalDeduction: normalizeValue(responseData?.totalDeduction, "0"),
+            remainingCollateral: normalizeValue(responseData?.remainingCollateral, "0"),
             newCollateralRatioBps: responseData?.newCollateralRatioBps,
             destinationAddress: responseData?.destinationAddress,
-            btcPrice: responseData?.btcPrice,
-            timestamp: responseData?.timestamp,
+            btcPrice: normalizeValue(responseData?.btcPrice, "5000000000000"), // Default: $50,000 with 8 decimals
+            timestamp: normalizeValue(responseData?.timestamp, Math.floor(Date.now() / 1000).toString()),
             utxoTxid: responseData?.utxoTxid, // Real Bitcoin UTXO txid from network query
             utxoVout: responseData?.utxoVout, // Real Bitcoin UTXO vout from network query
-            utxoSatoshis: responseData?.utxoSatoshis, // UTXO value for validation
+            utxoSatoshis: responseData?.utxoSatoshis ? normalizeValue(responseData?.utxoSatoshis, "0") : undefined, // UTXO value for validation
             reason: responseData?.reason,
             failedStep: responseData?.failedStep,
             error: result.error,
         };
+        console.log("🔍 STANDALONE PROCESSED RETURN VALUE:");
+        console.log("   returnValue.btcPrice:", returnValue.btcPrice, "type:", typeof returnValue.btcPrice);
+        console.log("   returnValue.btcPrice is empty object:", returnValue.btcPrice && typeof returnValue.btcPrice === 'object' && Object.keys(returnValue.btcPrice).length === 0);
         if (this.config.debug) {
             console.log("🎁 STANDALONE RETURN VALUE:", JSON.stringify(returnValue, null, 2));
         }