@gvnrdao/dh-lit-ops 0.0.33 → 0.0.39

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

@@ -289,7 +289,8 @@ class LitOps {
     /**
      * Execute a LIT Action from CID
      */
-    async executeActionFromCID(cid, pkpPublicKey, params, signer, pkpTokenId // Optional PKP token ID for session signature scoping
+    async executeActionFromCID(cid, pkpPublicKey, params, signer, pkpTokenId, // Optional PKP token ID for session signature scoping
+    pkpEthAddress // Optional PKP Ethereum address for capacity credit delegation
     ) {
         const litClient = await this.clientManager.getClient({
             litNetwork: this.config.network,
@@ -301,6 +302,7 @@ class LitOps {
             params,
             signer,
             pkpTokenId, // Pass through pkpTokenId for session signature scoping
+            pkpEthAddress, // Pass through pkpEthAddress for capacity delegation
         };
         return this.actionExecutor.executeAction(request, litClient);
     }
@@ -505,15 +507,18 @@ class LitOps {
      * @param signer - The wallet to use for PKP creation and transactions
      * @returns Complete PKP data including tokenId, publicKey, ethAddress, etc.
      */
-    async createProductionPKP(litActionCid, signer) {
+    async createProductionPKP(litActionCids, signer) {
+        // Normalize to array
+        const cids = Array.isArray(litActionCids) ? litActionCids : [litActionCids];
         if (this.config.debug) {
             console.log("\n🏗️ LitOps.createProductionPKP called");
-            console.log(`   LIT Action CID: ${litActionCid}`);
+            console.log(`   LIT Action CIDs (${cids.length}):`);
+            cids.forEach((cid, idx) => console.log(`     ${idx + 1}. ${cid}`));
             console.log(`   Network: ${this.config.network}`);
         }
-        // Create PKP with authorization and burn for immutability
+        // Create PKP with authorization of ALL actions and burn for immutability
         const pkpResult = await this.pkpMacroUtils.quickCreatePkpAuthorizeDhActionAndBurn(signer, {
-            litActionCid: litActionCid,
+            litActionCid: cids, // Pass array to authorize all actions before burn
         });
         if (this.config.debug) {
             console.log("   ✅ Production PKP created successfully!");
@@ -594,6 +599,14 @@ class LitOps {
      * @returns PKP validation result with signature verification
      */
     async validatePKPSecurity(targetPkpTokenId, expectedCid, signerPkp, signer) {
+        console.log(`🔍 LIT-OPS TRACE: validatePKPSecurity ENTRY`);
+        console.log(`   - targetPkpTokenId: "${targetPkpTokenId}"`);
+        console.log(`   - targetPkpTokenId type: ${typeof targetPkpTokenId}`);
+        console.log(`   - targetPkpTokenId length: ${targetPkpTokenId.length}`);
+        console.log(`   - targetPkpTokenId startsWith '0x': ${targetPkpTokenId.startsWith('0x')}`);
+        console.log(`   - expectedCid (WILL BE PASSED TO LIT ACTION): "${expectedCid}"`);
+        console.log(`   - signerPkp.tokenId: "${signerPkp.tokenId}"`);
+        console.log(`   - signerPkp.ethAddress: "${signerPkp.ethAddress}"`);
         if (this.config.debug) {
             console.log("\n🔍 LitOps.validatePKPSecurity");
             console.log(`   Target PKP: ${targetPkpTokenId}`);
@@ -601,26 +614,44 @@ class LitOps {
             console.log(`   Signer PKP: ${signerPkp.tokenId}`);
         }
         try {
-            // Get the PKP validator CID
-            const pkpValidatorCid = (this.config.network === "datil"
+            const targetPkpTokenIdDecimal = ethers_1.ethers.BigNumber.from(targetPkpTokenId).toString();
+            console.log(`   - targetPkpTokenId normalized (decimal): "${targetPkpTokenIdDecimal}"`);
+            // Get the PKP validator CID and PKP
+            const pkpValidatorConfig = (this.config.network === "datil"
                 ? dh_lit_actions_1.DH_LIT_ACTIONS_DATIL
-                : dh_lit_actions_1.DH_LIT_ACTIONS_DATIL_TEST).pkpValidator.cid;
+                : dh_lit_actions_1.DH_LIT_ACTIONS_DATIL_TEST).pkpValidator;
+            const pkpValidatorCid = pkpValidatorConfig.cid;
+            if (!pkpValidatorConfig.pkp || !pkpValidatorConfig.pkp.publicKey) {
+                throw new Error(`PKP validator configuration missing PKP public key for network: ${this.config.network}`);
+            }
+            const pkpValidatorPublicKey = pkpValidatorConfig.pkp.publicKey;
             if (this.config.debug) {
                 console.log(`   PKP Validator CID: ${pkpValidatorCid}`);
+                console.log(`   PKP Validator Public Key: ${pkpValidatorPublicKey}`);
             }
             // Execute PKP Validator LIT Action
-            // NOTE: We do NOT pass the validator PKP token ID here because the validator
-            // performs READ-ONLY operations (no signing). Passing undefined for pkpTokenId
-            // will skip adding LitPKPResource to the session signature, which is correct
-            // for burned/immutable validator PKPs that can't sign via session signatures.
-            const litResult = await this.executeActionFromCID(pkpValidatorCid, signerPkp.publicKey, {
-                targetPkpTokenId,
+            // IMPORTANT: We must use the VALIDATOR PKP's public key to execute the validator action,
+            // not the target PKP's public key. The validator PKP is authorized for the validator CID
+            // and CAN sign because we pass its token ID to enable LitPKPResource signing scope.
+            // Even though the validator PKP is burned/immutable, it can sign when executed via
+            // its authorized action context with proper PKP signing scope.
+            console.log(`\n🔍 LIT-OPS TRACE: About to call executeActionFromCID with jsParams:`);
+            console.log(`   - targetPkpTokenId (decimal sent to action): "${targetPkpTokenIdDecimal}"`);
+            console.log(`   - expectedCid: "${expectedCid}"`);
+            console.log(`   - validatorPkpTokenId (decimal): "${pkpValidatorConfig.pkp.tokenId}"`);
+            // Convert validator PKP token ID to hex format for LitPKPResource
+            // LitPKPResource requires hex format with 0x prefix (max 66 chars including 0x)
+            const validatorPkpTokenIdHex = ethers_1.ethers.BigNumber.from(pkpValidatorConfig.pkp.tokenId).toHexString();
+            console.log(`   - validatorPkpTokenId (hex): "${validatorPkpTokenIdHex}"`);
+            const litResult = await this.executeActionFromCID(pkpValidatorCid, pkpValidatorPublicKey, // Use validator PKP's public key, not target PKP's!
+            {
+                targetPkpTokenId: targetPkpTokenIdDecimal,
                 expectedCid, // Expected to be in hex format
                 message: `PKP validation: ${Date.now()}`,
                 // Ensure the LIT Action knows which network (datil vs datil-test)
                 network: this.config.network,
-            }, signer
-            // Intentionally NOT passing signerPkp.tokenId - validator is read-only
+                publicKey: pkpValidatorPublicKey, // Pass for signing context
+            }, signer, validatorPkpTokenIdHex // Pass validator PKP token ID in hex format for LitPKPResource
             );
             if (this.config.debug) {
                 console.log(`   LIT Action Success: ${litResult.success}`);
@@ -636,45 +667,14 @@ class LitOps {
                     const responseData = typeof litResult.response === "string"
                         ? JSON.parse(litResult.response)
                         : litResult.response;
-                    // Check if this is a signing error after successful validation
-                    // The LIT Action prints validation results to console before failing at signing
-                    const isSigningError = responseData.error &&
-                        (responseData.error.includes("Failed to sign ecdsa") ||
-                            responseData.error.includes("NodeAuthSigScopeTooLimited"));
-                    // If there's a signing error, treat it as expected for burned validator PKPs
-                    // and mark as success (validation passed, signing is known limitation)
-                    if (isSigningError) {
-                        if (this.config.debug) {
-                            console.log("   ⚠️  Signing failed (expected for burned validator PKPs)");
-                            console.log("   ✅ Treating as validation success - burn timing preserved");
-                        }
-                        // Override success flag - validation actually succeeded
-                        responseData.success = true;
-                        responseData.error = undefined;
-                        responseData.signatureNote =
-                            "Signing skipped - burned PKP architectural limitation";
-                        // Create synthetic validation result based on the fact that LIT Action ran
-                        responseData.validated = {
-                            exists: true, // PKP must exist for LIT Action to have run this far
-                            immutable: true, // We verify burn in previous step
-                            singleAction: true, // Assumed based on our authorization process
-                            correctCid: true, // Assumed based on our authorization process
-                        };
-                    }
-                    // Verify signature if present (optional for burned PKPs)
+                    // Verify signature (now required with proper PKP signing scope)
                     let signatureValid = false;
                     let pkpAddress = "";
                     let recoveredAddress = "";
                     let signedMessage;
-                    // For signing errors, we skip signature verification (architectural limitation)
-                    if (isSigningError) {
-                        signatureValid = true; // Mark as valid since validation succeeded
-                        if (this.config.debug) {
-                            console.log("   ℹ️  Signature verification skipped - burned PKP limitation");
-                        }
-                    }
-                    else if (litResult.signatures &&
-                        litResult.signatures.pkpValidation) {
+                    let messageDigest;
+                    if (litResult.signatures &&
+                        litResult.signatures.pkpValidatorSignature) {
                         if (this.config.debug) {
                             console.log("   🔍 Verifying signature authenticity...");
                         }
@@ -684,22 +684,30 @@ class LitOps {
                                 ? signerPkp.publicKey
                                 : `0x${signerPkp.publicKey}`;
                             pkpAddress = ethers_1.ethers.utils.computeAddress(cleanPublicKey);
-                            // Recover address from signature - LIT Action signs the keccak256 hash
-                            signedMessage = responseData.signedMessage;
-                            const signature = litResult.signatures.pkpValidation.signature;
+                            // Recover address from signature - LIT Action signs the Ethereum-prefixed hash
+                            // The PKP Validator returns certificationMessage, not signedMessage
+                            signedMessage = responseData.certificationMessage || responseData.signedMessage;
+                            messageDigest =
+                                responseData.messageHash ||
+                                    responseData.messageDigest ||
+                                    (signedMessage
+                                        ? ethers_1.ethers.utils.hashMessage(signedMessage)
+                                        : undefined);
+                            const signature = litResult.signatures.pkpValidatorSignature.signature;
                             if (this.config.debug) {
                                 console.log(`   🔍 DEBUG - Full responseData:`, JSON.stringify(responseData, null, 2));
                                 console.log(`   🔍 DEBUG - signedMessage from response:`, signedMessage);
                                 console.log(`   🔍 DEBUG - signature:`, signature);
                             }
                             if (signedMessage && signature) {
-                                // The LIT Action signs with Ethereum prefix using ethers.utils.hashMessage()
-                                const messageHash = ethers_1.ethers.utils.hashMessage(signedMessage);
-                                recoveredAddress = ethers_1.ethers.utils.recoverAddress(messageHash, signature);
+                                if (!messageDigest) {
+                                    throw new Error("Missing message digest for signature verification");
+                                }
+                                recoveredAddress = ethers_1.ethers.utils.verifyMessage(signedMessage, signature);
                                 signatureValid =
                                     pkpAddress.toLowerCase() === recoveredAddress.toLowerCase();
                                 if (this.config.debug) {
-                                    console.log(`   🔍 DEBUG - messageHash:`, messageHash);
+                                    console.log(`   🔍 DEBUG - messageDigest:`, messageDigest);
                                     console.log(`   PKP Address: ${pkpAddress}`);
                                     console.log(`   Recovered Address: ${recoveredAddress}`);
                                     console.log(`   Signature: ${signature}`);
@@ -722,11 +730,16 @@ class LitOps {
                                 : verifyError}`);
                         }
                     }
+                    else {
+                        // No signature found - this should not happen with proper PKP signing scope
+                        throw new Error("Validator PKP failed to generate signature. Ensure validator PKP token ID is passed for signing scope.");
+                    }
                     // Return parsed result
                     return {
                         success: responseData.success || false,
-                        signature: litResult.signatures?.pkpValidation?.signature,
+                        signature: litResult.signatures?.pkpValidatorSignature?.signature,
                         signedMessage, // Include the signedMessage for external verification
+                        messageDigest,
                         error: responseData.error,
                         signatureValid,
                         pkpAddress,
@@ -739,7 +752,6 @@ class LitOps {
                                 matchesExpectedCID: responseData.validated.correctCid || false,
                                 allValid: responseData.validated.exists &&
                                     responseData.validated.immutable &&
-                                    responseData.validated.singleAction &&
                                     responseData.validated.correctCid,
                             }
                             : undefined,
@@ -791,13 +803,16 @@ class LitOps {
      * @param signer - Optional signer (required for standalone mode, not used in service mode)
      * @returns Complete PKP creation and validation result with audit trail
      */
-    async createAndValidatePkpToLitAction(litActionCid, signer) {
+    async createAndValidatePkpToLitAction(litActionCids, signer) {
         const startTime = Date.now();
         const auditSteps = [];
+        // Normalize to array for processing
+        const cids = Array.isArray(litActionCids) ? litActionCids : [litActionCids];
         if (this.config.debug) {
             console.log("\n🎯 LitOps.createAndValidatePkpToLitAction");
             console.log("   ULTIMATE PKP SECURITY MACRO");
-            console.log(`   Target LIT Action CID: ${litActionCid}`);
+            console.log(`   Target LIT Action CIDs (${cids.length}):`);
+            cids.forEach((cid, idx) => console.log(`     ${idx + 1}. ${cid}`));
             console.log(`   Mode: ${this.config.mode}`);
         }
         // Service mode: Call the service endpoint directly
@@ -807,7 +822,7 @@ class LitOps {
             }
             const retries = this.config.pkpServiceRetryCount ?? 2;
             const retryDelay = this.config.pkpServiceRetryDelayMs ?? 2000;
-            const timeoutMs = this.config.pkpServiceTimeoutMs ?? 120000;
+            const timeoutMs = this.config.pkpServiceTimeoutMs ?? 480000; // 8 minutes to match server timeout
             let attempt = 0;
             let lastError = null;
             while (attempt <= retries) {
@@ -821,7 +836,7 @@ class LitOps {
                             "Content-Type": "application/json",
                         },
                         body: JSON.stringify({
-                            litActionCid: litActionCid,
+                            litActionCids: litActionCids,
                         }),
                     }, timeoutMs);
                     if (!response.ok) {
@@ -872,7 +887,9 @@ class LitOps {
                         error: message,
                         timestamp: startTime,
                         duration,
-                        targetCid: litActionCid,
+                        targetCid: Array.isArray(litActionCids)
+                            ? litActionCids[0]
+                            : litActionCids,
                         pkpData: {},
                         validationResult: {},
                         auditTrail: {
@@ -907,7 +924,7 @@ class LitOps {
             if (this.config.debug) {
                 console.log("\n   Step 1: Creating production PKP...");
             }
-            const pkpData = await this.createProductionPKP(litActionCid, signer);
+            const pkpData = await this.createProductionPKP(cids, signer);
             const step1Duration = Date.now() - step1Start;
             auditSteps.push({
                 step: 1,
@@ -956,10 +973,14 @@ class LitOps {
                 }
             }
             // Additional delay after burn verification for network consensus
+            // YELLOWSTONE PROPAGATION: Chronicle Yellowstone requires longer propagation time
+            // than other networks. Empirical testing shows 30-45s is needed for reliable RPC visibility.
+            const yellowstonePropagationDelayMs = 45000; // 45 seconds for Yellowstone reliability
             if (this.config.debug) {
-                console.log("\n   ⏳ Additional delay for network consensus (10 seconds)...");
+                console.log(`\n   ⏳ Additional delay for Yellowstone RPC propagation (${yellowstonePropagationDelayMs}ms)...`);
+                console.log(`   This ensures the PKP is visible to all RPC nodes before validation`);
             }
-            await new Promise((resolve) => setTimeout(resolve, 10000));
+            await new Promise((resolve) => setTimeout(resolve, yellowstonePropagationDelayMs));
             if (this.config.debug) {
                 console.log(`   ✅ Network propagation and consensus complete`);
             }
@@ -993,20 +1014,30 @@ class LitOps {
             if (!validatorPkp) {
                 throw new Error("PKP validator PKP not found in dh-lit-actions package");
             }
-            // Convert IPFS CID to hex format for validation
-            const litActionCidHex = (0, dh_lit_actions_1.cidToHex)(litActionCid);
+            // Convert IPFS CID to hex format for validation (using first CID)
+            const firstCid = cids[0];
+            console.log(`🔍 LIT-OPS TRACE: firstCid (cids[0]) = "${firstCid}"`);
+            console.log(`🔍 LIT-OPS TRACE: All cids array:`, cids);
+            const litActionCidHex = (0, dh_lit_actions_1.cidToHex)(firstCid);
+            console.log(`🔍 LIT-OPS TRACE: litActionCidHex after cidToHex() = "${litActionCidHex}"`);
             if (this.config.debug) {
-                console.log(`      Converting CID: ${litActionCid} → ${litActionCidHex}`);
+                console.log(`      Converting CID: ${firstCid} → ${litActionCidHex}`);
             }
             // Attempt validation with retry logic for network propagation issues
             let validationResult;
-            const maxValidationRetries = 2;
+            const maxValidationRetries = 3;
             let lastValidationError = null;
             for (let attempt = 1; attempt <= maxValidationRetries; attempt++) {
                 try {
                     if (this.config.debug && attempt > 1) {
                         console.log(`\n   🔄 Validation retry attempt ${attempt}/${maxValidationRetries}`);
                     }
+                    console.log(`🔍 LIT-OPS TRACE: validatePKPSecurity call parameters:`);
+                    console.log(`   - pkpTokenId: "${pkpData.tokenId}"`);
+                    console.log(`   - pkpTokenId type: ${typeof pkpData.tokenId}`);
+                    console.log(`   - pkpTokenId startsWith '0x': ${pkpData.tokenId.startsWith("0x")}`);
+                    console.log(`   - litActionCidHex (expectedCid): "${litActionCidHex}"`);
+                    console.log(`   - validatorPkp: "${validatorPkp}"`);
                     validationResult = await this.validatePKPSecurity(pkpData.tokenId, litActionCidHex, // Pass hex format CID
                     validatorPkp, signer);
                     // If validation succeeds, break out of retry loop
@@ -1020,7 +1051,7 @@ class LitOps {
                     lastValidationError = new Error(`PKP validation failed: ${validationResult.error || "Unknown validation error"}`);
                     // If not the last attempt, wait before retrying
                     if (attempt < maxValidationRetries) {
-                        const retryDelay = 10000; // 10 seconds between validation retries
+                        const retryDelay = 15000; // 15 seconds between validation retries
                         if (this.config.debug) {
                             console.log(`   ⏳ Waiting ${retryDelay}ms before retry...`);
                         }
@@ -1087,7 +1118,9 @@ class LitOps {
                 success: true,
                 timestamp: startTime,
                 duration: totalDuration,
-                targetCid: litActionCid,
+                targetCid: Array.isArray(litActionCids)
+                    ? litActionCids[0]
+                    : litActionCids,
                 pkpData,
                 validationResult,
                 auditTrail: {
@@ -1122,7 +1155,9 @@ class LitOps {
                 error: errorMessage,
                 timestamp: startTime,
                 duration: totalDuration,
-                targetCid: litActionCid,
+                targetCid: Array.isArray(litActionCids)
+                    ? litActionCids[0]
+                    : litActionCids,
                 pkpData: {}, // Empty PKP data on failure
                 validationResult: {
                     success: false,
@@ -1172,9 +1207,21 @@ class LitOps {
         if (this.config.mode === "standalone" && !effectiveSigner) {
             throw new Error("Signer is required for standalone mode");
         }
-        return this.createAndValidatePkpToLitAction(((networkOverride ?? this.config.network) === "datil"
+        const selectedNetwork = networkOverride ?? this.config.network;
+        const deployments = selectedNetwork === "datil"
             ? dh_lit_actions_1.DH_LIT_ACTIONS_DATIL
-            : dh_lit_actions_1.DH_LIT_ACTIONS_DATIL_TEST).authorizationDummy.cid, effectiveSigner);
+            : dh_lit_actions_1.DH_LIT_ACTIONS_DATIL_TEST;
+        const authorizationCid = deployments.authorizationDummy.cid;
+        const validatorCid = deployments.pkpValidator.cid;
+        const ucdMintCid = deployments.ucdMintValidator.cid;
+        console.log(`🔍 LIT-OPS TRACE: getNewDiamondHandsLoanPkp - selectedNetwork = "${selectedNetwork}"`);
+        console.log(`🔍 LIT-OPS TRACE: getNewDiamondHandsLoanPkp - authorizationDummy.cid = "${authorizationCid}"`);
+        console.log(`🔍 LIT-OPS TRACE: getNewDiamondHandsLoanPkp - pkpValidator.cid = "${validatorCid}"`);
+        console.log(`🔍 LIT-OPS TRACE: getNewDiamondHandsLoanPkp - ucdMintValidator.cid = "${ucdMintCid}"`);
+        // Pass validator CID first (for validation signature), then authorization CID (for authorization),
+        // and ucdMintValidator CID (for UCD minting operations)
+        // The validator will sign the FIRST CID (validator CID), which matches what the contract expects
+        return this.createAndValidatePkpToLitAction([validatorCid, authorizationCid, ucdMintCid], effectiveSigner);
     }
     /**
      * Request mint authorization from UCD Mint Validator LIT Action
@@ -1208,6 +1255,23 @@ class LitOps {
             litNetwork: this.config.network,
             debug: this.config.debug,
         });
+        // Determine chain from chainId in authMessage
+        let chain;
+        switch (request.authMessage.chainId) {
+            case 1:
+                chain = "ethereum";
+                break;
+            case 11155111:
+                chain = "sepolia";
+                break;
+            case 31337: // Hardhat local testnet
+                chain = "sepolia"; // Use sepolia config for local testing
+                break;
+            default:
+                throw new Error(`Unsupported chainId: ${request.authMessage.chainId}`);
+        }
+        // Bitcoin provider URL (use env or default to mempool.space for now)
+        const bitcoinProviderUrl = process.env.BITCOIN_PROVIDER_URL || "https://mempool.space/api";
         // Execute LIT Action
         // authMessage already contains quantumTimestamp calculated by SDK
         // lit-ops just forwards - no business logic
@@ -1215,8 +1279,13 @@ class LitOps {
             cid: litActionInfo.cid,
             pkpPublicKey: litActionInfo.pkp.publicKey,
             params: {
-                authMessage: request.authMessage,
-                userSignature: request.userSignature,
+                chain,
+                bitcoinProviderUrl,
+                auth: {
+                    message: request.authMessage,
+                    signature: request.userSignature,
+                },
+                amount: request.authMessage.requestedAmount,
             },
             signer: this.config.signer,
         }, litClient);
@@ -1229,18 +1298,134 @@ class LitOps {
         }
         // Return standardized response
         return {
-            success: result.success,
-            pkpSignature: result.signatures
+            approved: result.response?.approved ?? false,
+            signature: result.signatures
                 ? JSON.stringify(result.signatures)
                 : undefined,
             mintAmount: result.response?.mintAmount,
             mintFee: result.response?.mintFee,
             newDebt: result.response?.newDebt,
-            quantumTimestamp: result.response?.quantumTimestamp,
-            error: result.error,
-            details: result.response,
+            timestamp: result.response?.timestamp,
+            reason: result.response?.reason,
+            failedStep: result.response?.failedStep,
         };
     }
+    /**
+     * Get trustless BTC price from Price Oracle LIT Action
+     *
+     * Fetches the current BTC price in USD using the decentralized price oracle.
+     * Supports two modes:
+     * - fast: Single source (faster, less secure)
+     * - full: Consensus across multiple sources (slower, more secure)
+     *
+     * @param options - Price fetch options
+     * @returns BTC price data with optional signature
+     */
+    async getBTCPrice(options) {
+        const { mode = "fast", sign = false, signer } = options;
+        // Get LIT Action info from registry
+        const litActions = (this.config.network === "datil"
+            ? dh_lit_actions_1.DH_LIT_ACTIONS_DATIL
+            : dh_lit_actions_1.DH_LIT_ACTIONS_DATIL_TEST);
+        console.log("litActions in getActions", litActions);
+        const litActionInfo = litActions.priceOracle;
+        if (!litActionInfo || !litActionInfo.cid) {
+            return {
+                success: false,
+                error: "Price oracle LIT Action not found in registry",
+            };
+        }
+        if (this.config.debug) {
+            console.log("💰 Calling Price Oracle LIT Action:");
+            console.log("   Network:", this.config.network);
+            console.log("   CID:", litActionInfo.cid);
+            console.log("   Mode:", mode);
+            console.log("   Sign:", sign);
+        }
+        try {
+            // In service mode, do NOT attempt to create a Lit client; use HTTP service directly
+            if (this.config.mode === "service") {
+                const result = await this.actionExecutor.executeAction({
+                    cid: litActionInfo.cid,
+                    pkpPublicKey: litActionInfo.pkp?.publicKey || "",
+                    params: { mode, sign },
+                    signer: signer || this.config.signer,
+                }, undefined);
+                if (this.config.debug) {
+                    console.log("📥 Price Oracle response:", {
+                        success: result.success,
+                        response: result.response,
+                        error: result.error,
+                    });
+                }
+                if (result.success && result.response) {
+                    const responseData = typeof result.response === "string"
+                        ? JSON.parse(result.response)
+                        : result.response;
+                    return {
+                        success: true,
+                        priceE8: responseData.priceE8,
+                        price: responseData.price,
+                        timestamp: responseData.timestamp,
+                        source: responseData.source,
+                        signature: responseData.signature,
+                        signer: responseData.signer,
+                    };
+                }
+                return {
+                    success: false,
+                    error: result.error || "Price oracle execution failed",
+                };
+            }
+            // Standalone mode: require Lit client
+            const litClient = await this.clientManager.getClient({
+                litNetwork: this.config.network,
+                debug: this.config.debug,
+            });
+            const result = await this.actionExecutor.executeAction({
+                cid: litActionInfo.cid,
+                pkpPublicKey: litActionInfo.pkp?.publicKey || "",
+                params: { mode, sign },
+                signer: signer || this.config.signer,
+            }, litClient);
+            if (this.config.debug) {
+                console.log("📥 Price Oracle response:", {
+                    success: result.success,
+                    response: result.response,
+                    error: result.error,
+                });
+            }
+            // Parse response
+            if (result.success && result.response) {
+                const responseData = typeof result.response === "string"
+                    ? JSON.parse(result.response)
+                    : result.response;
+                return {
+                    success: true,
+                    priceE8: responseData.priceE8,
+                    price: responseData.price,
+                    timestamp: responseData.timestamp,
+                    source: responseData.source,
+                    signature: responseData.signature,
+                    signer: responseData.signer,
+                };
+            }
+            return {
+                success: false,
+                error: result.error || "Price oracle execution failed",
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            if (this.config.debug) {
+                console.error("❌ Price oracle failed:", error);
+            }
+            return {
+                success: false,
+                error: errorMessage,
+            };
+        }
+    }
     /**
      * Cleanup - disconnect all clients
      */