@gvnrdao/dh-sdk 0.0.1

package/dist/modules/diamond-hands-sdk.module.js

@@ -0,0 +1,773 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiamondHandsSDK = void 0;
+const dh_lit_ops_1 = require("@gvnrdao/dh-lit-ops");
+const ethers_1 = require("ethers");
+const utils_1 = require("../utils");
+// Position Manager ABI for smart contract interaction
+const POSITION_MANAGER_ABI = [
+    "function createPosition(bytes32 pkpId, uint256 amount, uint256 requestedCollateralRatio, uint256 selectedTerm, bytes calldata validatorSignature) external returns (bool)",
+    "function calculateCollateralRatio(bytes32 positionId) external view returns (uint256)",
+    "function getPositionDetails(bytes32 positionId) external view returns (tuple(bytes32 positionId, bytes32 pkpId, address borrower, uint256 btcAmount, uint256 ucdDebt, uint256 createdAt, uint256 lastUpdated, bool isActive, uint256 collateralRatio, uint256 requestedCollateralRatio, uint256 selectedTerm))",
+    "function getUserPositions(address user) external view returns (bytes32[] memory)",
+    "function getPositionByPKP(bytes32 pkpId) external view returns (bytes32)",
+    "function getPKPPositionData(bytes32 pkpId) external view returns (tuple(bytes32 positionId, address borrower, uint256 amount, uint256 requestedCollateralRatio, uint256 selectedTerm, uint256 createdAt, bool isActive))",
+    "function getPKPLoanParams(bytes32 pkpId) external view returns (uint256 amount, uint256 requestedCollateralRatio, uint256 selectedTerm)",
+    "event PositionCreated(bytes32 indexed positionId, bytes32 indexed pkpId, address indexed borrower, uint256 amount, uint256 requestedCollateralRatio, uint256 selectedTerm)",
+];
+/**
+ * Core Diamond Hands SDK Module
+ *
+ * This is the main SDK class that provides a high-level interface for Diamond Hands Protocol operations.
+ * It supports two operation modes:
+ * - Standalone: User provides signer and network, SDK creates PKPs directly via LIT Protocol
+ * - Service: SDK calls lit-ops-server backend which handles LIT Protocol operations
+ *
+ * Default behavior (if mode not specified):
+ * - Mode: "service"
+ * - Service endpoint: "http://localhost:3001"
+ */
+class DiamondHandsSDK {
+    constructor(config) {
+        this.litOps = null;
+        this.initialized = false;
+        this.config = config;
+        // Apply smart defaults
+        this.mode = config.mode || "service"; // Default to service mode
+        this.serviceEndpoint = config.serviceEndpoint || "http://localhost:3001"; // Default to localhost
+        // In service mode, use contractSigner's provider if available, otherwise create from ethRpcUrl
+        if (config.ethRpcUrl) {
+            this.provider = new ethers_1.ethers.providers.JsonRpcProvider(config.ethRpcUrl);
+        }
+        else if (config.contractSigner &&
+            "provider" in config.contractSigner &&
+            config.contractSigner.provider) {
+            // Use MetaMask's provider for blockchain interactions
+            this.provider = config.contractSigner
+                .provider;
+        }
+        else {
+            // Fallback: will be set later when contractSigner is available
+            this.provider = null;
+        }
+        // Validate configuration based on mode
+        this.validateConfig();
+        if (this.config.debug) {
+            console.log("🏗️ Diamond Hands SDK initialized with config:");
+            console.log(`   Mode: ${this.mode}`);
+            if (this.mode === "standalone") {
+                console.log(`   Network: ${config.litNetwork}`);
+                console.log(`   LIT-Ops Signer: ${config.litOpsSigner?.address}`);
+            }
+            else {
+                console.log(`   Service Endpoint: ${this.serviceEndpoint}`);
+            }
+            console.log(`   Contract: ${config.contractAddresses.positionManager}`);
+        }
+    }
+    /**
+     * Validate configuration based on the selected mode
+     */
+    validateConfig() {
+        if (this.mode === "standalone") {
+            if (!this.config.litOpsSigner) {
+                throw new Error("litOpsSigner is required for standalone mode");
+            }
+            if (!this.config.litNetwork) {
+                throw new Error("litNetwork is required for standalone mode");
+            }
+            if (!this.config.ethRpcUrl) {
+                throw new Error("ethRpcUrl is required for standalone mode");
+            }
+            if (this.config.serviceEndpoint) {
+                throw new Error("serviceEndpoint must not be provided for standalone mode");
+            }
+        }
+        else if (this.mode === "service") {
+            if (this.config.litOpsSigner) {
+                throw new Error("litOpsSigner must not be provided for service mode");
+            }
+            if (this.config.litNetwork) {
+                throw new Error("litNetwork must not be provided for service mode (determined by serviceEndpoint)");
+            }
+            // In service mode, either ethRpcUrl or contractSigner with provider is required
+            if (!this.config.ethRpcUrl && !this.config.contractSigner) {
+                throw new Error("Service mode requires either ethRpcUrl or contractSigner for blockchain operations");
+            }
+        }
+    }
+    /**
+     * Initialize the SDK with required dependencies
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            if (this.config.debug) {
+                console.log("🚀 Initializing Diamond Hands SDK...");
+                console.log(`   Mode: ${this.mode}`);
+            }
+            // Initialize LitOps only for standalone mode
+            if (this.mode === "standalone") {
+                if (this.config.debug) {
+                    console.log("🔧 Initializing LitOps for standalone mode");
+                }
+                // LitOps will be initialized with signer during operations
+                // to support different signers for different operations
+            }
+            else {
+                if (this.config.debug) {
+                    console.log(`🌐 Service mode - using endpoint: ${this.serviceEndpoint}`);
+                }
+                // Service mode - no LitOps initialization needed
+            }
+            this.initialized = true;
+            if (this.config.debug) {
+                console.log("✅ Diamond Hands SDK initialized successfully");
+            }
+        }
+        catch (error) {
+            throw new Error(`SDK initialization failed: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    /**
+     * Create a new Diamond Hands loan by:
+     * 1. Creating and validating a PKP (via standalone LitOps or service endpoint)
+     * 2. Extracting the validator signature from PKP creation result
+     * 3. Funding the contract wallet if needed
+     * 4. Calling the smart contract createPosition method with PKP validator signature
+     */
+    async createLoan(request) {
+        this.ensureInitialized();
+        try {
+            if (this.config.debug) {
+                console.log("🏦 Starting Diamond Hands loan creation");
+                console.log(`   Mode: ${this.mode}`);
+                console.log(`   Collateral Amount: ${request.collateralAmount}`);
+                console.log(`   Collateral Ratio: ${request.collateralRatio}%`);
+                console.log(`   Selected Term: ${request.selectedTerm} months`);
+            }
+            // Step 1: Create PKP using the appropriate mode
+            let pkpResult;
+            if (this.mode === "standalone") {
+                pkpResult = await this.createLoanStandalone(request);
+            }
+            else {
+                pkpResult = await this.createLoanService(request);
+            }
+            return pkpResult;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (this.config.debug) {
+                console.error("❌ Loan creation failed:", errorMessage);
+                console.error("Full error:", error);
+            }
+            return {
+                success: false,
+                error: `Loan creation failed: ${errorMessage}`,
+            };
+        }
+    }
+    /**
+     * Create loan in standalone mode - uses LitOps directly
+     */
+    async createLoanStandalone(request) {
+        if (this.config.debug) {
+            console.log("🔧 Standalone mode: Creating loan with LitOps");
+            console.log(`   Network: ${this.config.litNetwork}`);
+        }
+        // Create dual-wallet setup (matching the working contract integration test)
+        // A) LIT-Ops wallet: Use the configured litOpsSigner with Yellowstone provider
+        if (!this.config.litOpsSigner) {
+            throw new Error("litOpsSigner is required in DiamondHandsSDKConfig for standalone mode");
+        }
+        const litProviderV5 = new ethers_1.ethers.providers.JsonRpcProvider("https://yellowstone-rpc.litprotocol.com");
+        const litOpsWallet = this.config.litOpsSigner.connect(litProviderV5);
+        // Setup contract wallet
+        const contractWallet = await this.setupContractWallet();
+        if (this.config.debug) {
+            console.log("🔧 Dual-wallet setup:");
+            console.log(`   LIT-Ops wallet: ${litOpsWallet.address} (Yellowstone RPC)`);
+            const contractAddress = await contractWallet.getAddress();
+            console.log(`   Contract wallet: ${contractAddress} (Local RPC)`);
+            console.log(`   Wallets match: ${litOpsWallet.address === contractAddress}`);
+        }
+        // Initialize LitOps with the LIT-specific wallet
+        if (!this.litOps) {
+            this.litOps = new dh_lit_ops_1.LitOps({
+                mode: "standalone",
+                network: this.config.litNetwork || "datil-test",
+                signer: litOpsWallet, // Use LIT-Ops wallet with Yellowstone provider
+                debug: this.config.debug,
+            });
+        }
+        // Step 1: Create and validate PKP using lit-ops production method
+        if (this.config.debug) {
+            console.log("📝 Step 1: Creating PKP via LIT-Ops getNewDiamondHandsLoanPkp");
+        }
+        let pkpResult = await this.createPKPWithRetry(litOpsWallet);
+        if (!pkpResult.success) {
+            throw new Error(`PKP creation failed: ${pkpResult.error}`);
+        }
+        return this.processLoanCreation(pkpResult, contractWallet, request);
+    }
+    /**
+     * Create loan in service mode - calls lit-ops-server
+     */
+    async createLoanService(request) {
+        if (this.config.debug) {
+            console.log("🌐 Service mode: Creating loan via lit-ops-server");
+            console.log(`   Service endpoint: ${this.serviceEndpoint}`);
+        }
+        // Step 1: Call service endpoint to create PKP
+        if (this.config.debug) {
+            console.log("📝 Step 1: Creating PKP via service endpoint");
+        }
+        const response = await fetch(`${this.serviceEndpoint}/api/lit/pkp/create-diamond-hands-loan`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({}), // Empty body, service handles PKP creation
+        });
+        if (!response.ok) {
+            throw new Error(`Service call failed: ${response.status} ${response.statusText}`);
+        }
+        const pkpResult = await response.json();
+        if (!pkpResult.success) {
+            throw new Error(`Service PKP creation failed: ${pkpResult.error || "Unknown error"}`);
+        }
+        if (this.config.debug) {
+            console.log("✅ Service PKP creation successful");
+            console.log(`   Token ID: ${pkpResult.pkpData?.tokenId}`);
+            console.log(`   ETH Address: ${pkpResult.pkpData?.ethAddress}`);
+        }
+        // Setup contract wallet for local operations
+        const contractWallet = await this.setupContractWallet();
+        // Convert service response to expected format
+        const formattedPkpResult = {
+            success: true,
+            pkpData: {
+                tokenId: pkpResult.pkpData?.tokenId,
+                ethAddress: pkpResult.pkpData?.ethAddress,
+                publicKey: pkpResult.pkpData?.publicKey,
+                validationSignature: pkpResult.validationResult?.signature,
+                // Include Bitcoin addresses if available
+                btcAddresses: pkpResult.pkpData?.btcAddresses,
+            },
+            auditTrail: {
+                steps: pkpResult.auditTrail?.steps || [],
+            },
+            // Include validation results
+            validationResult: pkpResult.validationResult,
+        };
+        return this.processLoanCreation(formattedPkpResult, contractWallet, request, true);
+    }
+    /**
+     * Setup contract wallet for Ethereum transactions
+     */
+    async setupContractWallet() {
+        if (!this.config.contractSigner) {
+            throw new Error("contractSigner is required in DiamondHandsSDKConfig for contract operations");
+        }
+        let contractWallet;
+        if ("privateKey" in this.config.contractSigner &&
+            this.config.contractSigner.privateKey) {
+            // If signer is a Wallet with private key, connect it to local provider
+            contractWallet = new ethers_1.ethers.Wallet(this.config.contractSigner.privateKey, this.provider);
+        }
+        else {
+            // If signer is already connected (e.g., MetaMask), use it directly
+            contractWallet = this.config.contractSigner;
+        }
+        return contractWallet;
+    }
+    /**
+     * Create PKP with retry logic for LIT Protocol network issues
+     */
+    async createPKPWithRetry(litOpsWallet) {
+        let pkpResult;
+        let retryAttempted = false;
+        // Attempt PKP creation with retry logic for LIT Protocol network issues
+        try {
+            pkpResult = await this.litOps.getNewDiamondHandsLoanPkp(litOpsWallet // Use LIT-Ops wallet for PKP operations
+            );
+        }
+        catch (error) {
+            // Check if this is the known LIT SDK event parsing issue
+            if (!retryAttempted &&
+                error.message?.includes("Cannot read properties of undefined (reading 'topics')")) {
+                if (this.config.debug) {
+                    console.log("⚠️ LIT SDK event parsing failed, retrying once...");
+                }
+                retryAttempted = true;
+                // Wait a bit for network to settle
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+                // Retry once
+                try {
+                    pkpResult = await this.litOps.getNewDiamondHandsLoanPkp(litOpsWallet // Use LIT-Ops wallet for retry too
+                    );
+                }
+                catch (retryError) {
+                    if (this.config.debug) {
+                        console.log("❌ Retry also failed, this is a persistent LIT Protocol issue");
+                    }
+                    throw new Error(`PKP creation failed after retry: ${retryError instanceof Error ? retryError.message : retryError}`);
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+        return pkpResult;
+    }
+    /**
+     * Process loan creation after PKP is created - handle signature extraction and contract calls
+     */
+    async processLoanCreation(pkpResult, contractWallet, request, isServiceMode = false) {
+        // Extract PKP data from result (following the test logic)
+        let createdPkpTokenId;
+        let createdPkpAddress;
+        let createdPkpPublicKey;
+        if (pkpResult.pkpData) {
+            createdPkpTokenId = pkpResult.pkpData.tokenId || "";
+            createdPkpAddress = pkpResult.pkpData.ethAddress || "";
+            createdPkpPublicKey = pkpResult.pkpData.publicKey || "";
+            if (this.config.debug) {
+                console.log("✅ Using PKP data from main result");
+            }
+        }
+        else if (pkpResult.auditTrail &&
+            pkpResult.auditTrail.steps &&
+            pkpResult.auditTrail.steps.length > 0) {
+            const creationStep = pkpResult.auditTrail.steps.find((step) => step.description.includes("Create production PKP") && step.data);
+            if (creationStep && creationStep.data) {
+                createdPkpTokenId = creationStep.data.tokenId;
+                createdPkpAddress = creationStep.data.ethAddress;
+                createdPkpPublicKey = creationStep.data.publicKey;
+                if (this.config.debug) {
+                    console.log("✅ Using PKP data from audit trail");
+                }
+            }
+            else {
+                throw new Error("No valid PKP data found in result or audit trail");
+            }
+        }
+        else {
+            throw new Error("PKP creation failed completely with no audit trail");
+        }
+        if (this.config.debug) {
+            console.log("✅ PKP Data Extracted:");
+            console.log(`   Token ID: ${createdPkpTokenId}`);
+            console.log(`   ETH Address: ${createdPkpAddress}`);
+            console.log(`   Public Key: ${createdPkpPublicKey}`);
+        }
+        // Step 2: Extract the validator signature from the PKP creation result
+        if (this.config.debug) {
+            console.log("📝 Step 2: Extracting validator signature from PKP creation");
+        }
+        let validatorSignature;
+        if (isServiceMode) {
+            // Service mode: Use signature from service response
+            if (pkpResult.pkpData?.validationSignature) {
+                validatorSignature = pkpResult.pkpData.validationSignature;
+                if (this.config.debug) {
+                    console.log(`✅ Service mode: Validator signature extracted: ${validatorSignature}`);
+                }
+            }
+            else if (pkpResult.validationResult?.signature) {
+                // Fallback to validation result
+                validatorSignature = pkpResult.validationResult.signature;
+                if (this.config.debug) {
+                    console.log(`✅ Service mode: Validator signature extracted (fallback): ${validatorSignature}`);
+                }
+            }
+            else {
+                throw new Error("Service response missing validation signature");
+            }
+        }
+        else {
+            // Standalone mode: Extract signature from PKP result
+            // The signature is in the signatures.pkpValidation.signature field
+            if (pkpResult.signatures &&
+                pkpResult.signatures.pkpValidation &&
+                pkpResult.signatures.pkpValidation.signature) {
+                validatorSignature = pkpResult.signatures.pkpValidation.signature;
+                if (this.config.debug) {
+                    console.log(`✅ Validator signature extracted: ${validatorSignature}`);
+                }
+            }
+            else if (pkpResult.validationResult &&
+                pkpResult.validationResult.signature) {
+                // Fallback to old structure
+                validatorSignature = pkpResult.validationResult.signature;
+                if (this.config.debug) {
+                    console.log(`✅ Validator signature extracted (fallback): ${validatorSignature}`);
+                }
+            }
+            else {
+                if (this.config.debug) {
+                    console.log("PKP Result structure:", JSON.stringify(pkpResult, null, 2));
+                }
+                throw new Error("No validator signature found in PKP creation result");
+            }
+        }
+        const signature = validatorSignature;
+        if (this.config.debug) {
+            console.log(`✅ PKP Signature ready: ${signature}`);
+        }
+        // Convert tokenId to bytes32 for contract calls
+        const pkpId = ethers_1.ethers.utils.hexZeroPad(ethers_1.ethers.utils.hexlify(createdPkpTokenId), 32);
+        // Step 3: Prepare and execute contract transaction
+        if (this.config.debug) {
+            console.log("📝 Step 3: Executing smart contract transaction");
+        }
+        // Check if wallet needs funding
+        const contractWalletAddress = await contractWallet.getAddress();
+        const walletBalance = await this.provider.getBalance(contractWalletAddress);
+        if (walletBalance.lt(ethers_1.ethers.utils.parseEther("0.1"))) {
+            if (this.config.debug) {
+                console.log(`💰 Contract wallet balance low (${ethers_1.ethers.utils.formatEther(walletBalance)} ETH), funding may be required`);
+            }
+        }
+        // Prepare contract interaction using contract wallet
+        const contract = new ethers_1.ethers.Contract(this.config.contractAddresses.positionManager, POSITION_MANAGER_ABI, contractWallet // Use contract wallet for local network operations
+        );
+        // Convert collateralAmount from BTC to satoshis (8 decimal places)
+        // Note: collateralAmount should be in BTC units as per contract interface
+        const amount = ethers_1.ethers.utils.parseUnits(request.collateralAmount.toString(), 8); // Convert collateralAmount (BTC) to satoshis for contract call
+        // Convert collateralRatio to basis points (multiply by 100)
+        const requestedCollateralRatioBasisPoints = request.collateralRatio * 100;
+        if (this.config.debug) {
+            console.log("📝 Calling smart contract createPosition");
+            console.log(`   PKP ID (bytes32): ${pkpId}`);
+            console.log(`   Amount: ${amount}`);
+            console.log(`   Requested Collateral Ratio: ${requestedCollateralRatioBasisPoints} (${request.collateralRatio}%)`);
+            console.log(`   Selected Term: ${request.selectedTerm} months`);
+            console.log(`   Signature: ${signature}`);
+            console.log(`   Contract: ${this.config.contractAddresses.positionManager}`);
+        }
+        // Step 4: Call smart contract createPosition with validator signature and new parameters
+        const tx = await contract.createPosition(pkpId, amount, requestedCollateralRatioBasisPoints, request.selectedTerm, signature);
+        const receipt = await tx.wait();
+        if (this.config.debug) {
+            console.log("✅ Position created successfully!");
+            console.log(`   Transaction hash: ${tx.hash}`);
+            console.log(`   Gas used: ${receipt.gasUsed}`);
+            console.log(`   Collateral Ratio: ${request.collateralRatio}%`);
+            console.log(`   Loan Term: ${request.selectedTerm} months`);
+            console.log(`   Mode: ${isServiceMode ? "service" : "standalone"}`);
+        }
+        // Extract position ID from events
+        const positionCreatedEvent = receipt.logs?.find((log) => {
+            try {
+                const parsed = contract.interface.parseLog(log);
+                return parsed?.name === "PositionCreated";
+            }
+            catch {
+                return false;
+            }
+        });
+        let positionId;
+        if (positionCreatedEvent) {
+            const parsed = contract.interface.parseLog(positionCreatedEvent);
+            positionId = parsed?.args?.positionId || "";
+        }
+        else {
+            // Fallback: generate position ID
+            const borrowerAddress = await contractWallet.getAddress();
+            positionId = ethers_1.ethers.utils.keccak256(ethers_1.ethers.utils.solidityPack(["bytes32", "address", "uint256"], [pkpId, borrowerAddress, Date.now()]));
+        }
+        // Generate Bitcoin addresses from PKP public key (if available)
+        let btcAddresses;
+        if (createdPkpPublicKey) {
+            btcAddresses = (0, utils_1.getBitcoinAddressesFromPkp)(createdPkpPublicKey);
+            if (this.config.debug) {
+                console.log("📝 Step 4: Bitcoin addresses generated from PKP");
+                console.log(`   Mainnet: ${btcAddresses.mainnet}`);
+                console.log(`   Testnet: ${btcAddresses.testnet}`);
+                console.log(`   Regtest: ${btcAddresses.regtest}`);
+            }
+        }
+        return {
+            success: true,
+            transactionHash: tx.hash,
+            positionId: positionId,
+            pkpData: {
+                tokenId: createdPkpTokenId,
+                publicKey: createdPkpPublicKey,
+                ethAddress: createdPkpAddress,
+                validationSignature: validatorSignature,
+                btcAddresses: btcAddresses || {
+                    mainnet: "",
+                    testnet: "",
+                    regtest: "",
+                },
+            },
+            auditTrail: {
+                pkpCreation: pkpResult.auditTrail,
+                validation: { signatureGeneration: validatorSignature },
+                contractCall: {
+                    transactionHash: tx.hash,
+                    positionId: positionId,
+                },
+            },
+        };
+    }
+    /**
+     * Get single loan by vault address
+     */
+    async getLoan(vaultAddress) {
+        this.ensureInitialized();
+        try {
+            const contract = new ethers_1.ethers.Contract(this.config.contractAddresses.positionManager, POSITION_MANAGER_ABI, this.provider);
+            // For now, we'll need to implement position lookup by vault address
+            // This would require additional contract methods or event querying
+            // Placeholder implementation:
+            throw new Error("getLoan not implemented yet - requires contract method to lookup by vault address");
+        }
+        catch (error) {
+            if (this.config.debug) {
+                console.error("Failed to get loan:", error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Get loans by various criteria
+     */
+    async getLoans(query) {
+        this.ensureInitialized();
+        try {
+            // This would require implementing query methods in the smart contract
+            // or querying events from the blockchain
+            throw new Error("getLoans not implemented yet - requires contract query methods");
+        }
+        catch (error) {
+            if (this.config.debug) {
+                console.error("Failed to get loans:", error);
+            }
+            return [];
+        }
+    }
+    /**
+     * Get all positions for a user
+     */
+    async getUserPositions(userAddress) {
+        this.ensureInitialized();
+        try {
+            if (this.config.debug) {
+                console.log(`📋 Getting positions for user: ${userAddress}`);
+            }
+            const contract = new ethers_1.ethers.Contract(this.config.contractAddresses.positionManager, POSITION_MANAGER_ABI, this.provider);
+            // Call contract method to get user positions
+            const positionIds = await contract.getUserPositions(userAddress);
+            if (this.config.debug) {
+                console.log(`   Found ${positionIds.length} positions`);
+            }
+            // Get details for each position
+            const positions = [];
+            for (const positionId of positionIds) {
+                try {
+                    const positionDetails = await contract.getPositionDetails(positionId);
+                    positions.push({
+                        positionId: positionDetails.positionId,
+                        pkpId: positionDetails.pkpId,
+                        vaultAddress: positionDetails.pkpId, // Using pkpId as vault address for now
+                        borrower: positionDetails.borrower,
+                        collateralAmount: parseInt(ethers_1.ethers.utils.formatUnits(positionDetails.btcAmount, 8)),
+                        ucdDebt: parseInt(ethers_1.ethers.utils.formatEther(positionDetails.ucdDebt)),
+                        collateralRatio: positionDetails.collateralRatio,
+                        status: positionDetails.isActive ? "active" : "closed",
+                        createdAt: positionDetails.createdAt.toNumber(),
+                        lastUpdated: positionDetails.lastUpdated.toNumber(),
+                    });
+                }
+                catch (error) {
+                    if (this.config.debug) {
+                        console.warn(`Failed to get details for position ${positionId}:`, error);
+                    }
+                }
+            }
+            return positions;
+        }
+        catch (error) {
+            if (this.config.debug) {
+                console.error("Failed to get user positions:", error);
+            }
+            return [];
+        }
+    }
+    /**
+     * Get position details by PKP ID
+     */
+    async getPositionByPKP(pkpId) {
+        this.ensureInitialized();
+        try {
+            if (this.config.debug) {
+                console.log(`🔍 Getting position for PKP: ${pkpId}`);
+            }
+            const contract = new ethers_1.ethers.Contract(this.config.contractAddresses.positionManager, POSITION_MANAGER_ABI, this.provider);
+            // Convert PKP ID to bytes32 if needed
+            const pkpIdBytes32 = ethers_1.ethers.utils.hexZeroPad(pkpId, 32);
+            // Get position ID from PKP
+            const positionId = await contract.getPositionByPKP(pkpIdBytes32);
+            if (positionId === ethers_1.ethers.constants.HashZero) {
+                if (this.config.debug) {
+                    console.log("   No position found for this PKP");
+                }
+                return null;
+            }
+            // Get position details
+            const positionDetails = await contract.getPositionDetails(positionId);
+            return {
+                positionId: positionDetails.positionId,
+                pkpId: positionDetails.pkpId,
+                vaultAddress: positionDetails.pkpId, // Using pkpId as vault address for now
+                borrower: positionDetails.borrower,
+                collateralAmount: parseInt(ethers_1.ethers.utils.formatUnits(positionDetails.btcAmount, 8)),
+                ucdDebt: parseInt(ethers_1.ethers.utils.formatEther(positionDetails.ucdDebt)),
+                collateralRatio: positionDetails.collateralRatio,
+                status: positionDetails.isActive ? "active" : "closed",
+                createdAt: positionDetails.createdAt.toNumber(),
+                lastUpdated: positionDetails.lastUpdated.toNumber(),
+            };
+        }
+        catch (error) {
+            if (this.config.debug) {
+                console.error("Failed to get position by PKP:", error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Get PKP loan parameters (amount, collateral ratio, term) directly by PKP ID
+     * This uses the optimized storage for quick access to core loan parameters
+     */
+    async getPKPLoanParams(pkpId) {
+        this.ensureInitialized();
+        try {
+            if (this.config.debug) {
+                console.log(`📊 Getting PKP loan parameters for PKP: ${pkpId}`);
+            }
+            const contract = new ethers_1.ethers.Contract(this.config.contractAddresses.positionManager, POSITION_MANAGER_ABI, this.provider);
+            // Convert PKP ID to bytes32 if needed
+            const pkpIdBytes32 = ethers_1.ethers.utils.hexZeroPad(pkpId, 32);
+            // Get loan parameters directly from PKP storage
+            const [amount, requestedCollateralRatio, selectedTerm] = await contract.getPKPLoanParams(pkpIdBytes32);
+            if (amount.eq(0)) {
+                if (this.config.debug) {
+                    console.log("   No loan parameters found for this PKP");
+                }
+                return null;
+            }
+            const result = {
+                amount: parseInt(ethers_1.ethers.utils.formatUnits(amount, 8)),
+                requestedCollateralRatio: requestedCollateralRatio.toNumber() / 100, // Convert from basis points
+                selectedTerm: selectedTerm.toNumber(),
+            };
+            if (this.config.debug) {
+                console.log(`   Amount: ${result.amount} BTC`);
+                console.log(`   Collateral Ratio: ${result.requestedCollateralRatio}%`);
+                console.log(`   Term: ${result.selectedTerm} months`);
+            }
+            return result;
+        }
+        catch (error) {
+            if (this.config.debug) {
+                console.error("Failed to get PKP loan parameters:", error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Get complete PKP position data by PKP ID
+     * This provides all stored PKP position information in one call
+     */
+    async getPKPPositionData(pkpId) {
+        this.ensureInitialized();
+        try {
+            if (this.config.debug) {
+                console.log(`📋 Getting complete PKP position data for PKP: ${pkpId}`);
+            }
+            const contract = new ethers_1.ethers.Contract(this.config.contractAddresses.positionManager, POSITION_MANAGER_ABI, this.provider);
+            // Convert PKP ID to bytes32 if needed
+            const pkpIdBytes32 = ethers_1.ethers.utils.hexZeroPad(pkpId, 32);
+            // Get complete PKP position data
+            const pkpData = await contract.getPKPPositionData(pkpIdBytes32);
+            if (!pkpData.isActive && pkpData.amount.eq(0)) {
+                if (this.config.debug) {
+                    console.log("   No position data found for this PKP");
+                }
+                return null;
+            }
+            return {
+                positionId: pkpData.positionId,
+                borrower: pkpData.borrower,
+                amount: parseInt(ethers_1.ethers.utils.formatUnits(pkpData.amount, 8)),
+                requestedCollateralRatio: pkpData.requestedCollateralRatio.toNumber() / 100, // Convert from basis points
+                selectedTerm: pkpData.selectedTerm.toNumber(),
+                createdAt: pkpData.createdAt.toNumber(),
+                isActive: pkpData.isActive,
+            };
+        }
+        catch (error) {
+            if (this.config.debug) {
+                console.error("Failed to get PKP position data:", error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Request UCD minting for a loan
+     */
+    async requestMintUCD(request) {
+        this.ensureInitialized();
+        try {
+            if (this.config.debug) {
+                console.log("🪙 Requesting UCD minting...");
+            }
+            // This would call the mintUCD method on the position manager contract
+            throw new Error("requestMintUCD not implemented yet - requires mintUCD contract method");
+        }
+        catch (error) {
+            throw new Error(`UCD minting failed: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    /**
+     * Request loan liquidation
+     */
+    async requestLiquidation(request) {
+        this.ensureInitialized();
+        try {
+            if (this.config.debug) {
+                console.log("⚡ Requesting loan liquidation...");
+            }
+            // This would call the liquidatePosition method on the position manager contract
+            throw new Error("requestLiquidation not implemented yet - requires liquidatePosition contract method");
+        }
+        catch (error) {
+            throw new Error(`Liquidation failed: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    /**
+     * Cleanup SDK resources
+     */
+    async destroy() {
+        if (this.litOps) {
+            await this.litOps.disconnect();
+            this.litOps = null;
+        }
+        this.initialized = false;
+        if (this.config.debug) {
+            console.log("🧹 SDK cleanup complete");
+        }
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error("SDK not initialized. Call initialize() first.");
+        }
+    }
+}
+exports.DiamondHandsSDK = DiamondHandsSDK;