@gvnrdao/dh-sdk 0.0.1

package/dist/interfaces/chunks/utility.i.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Utility Type Interfaces
+ */
+/**
+ * Generic Result Interface
+ */
+export interface Result<T = any> {
+    success: boolean;
+    error?: string;
+    data?: T;
+}
+/**
+ * Pagination Interface
+ */
+export interface Pagination {
+    page: number;
+    limit: number;
+    total?: number;
+    hasNext?: boolean;
+    hasPrev?: boolean;
+}
+/**
+ * Paginated Result Interface
+ */
+export interface PaginatedResult<T = any> extends Result<T[]> {
+    pagination?: Pagination;
+}
+/**
+ * Audit Trail Interface
+ */
+export interface AuditTrail {
+    operation: string;
+    timestamp: number;
+    duration?: number;
+    success: boolean;
+    error?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Debug Information Interface
+ */
+export interface DebugInfo {
+    logs: string[];
+    metrics?: {
+        startTime: number;
+        endTime: number;
+        duration: number;
+    };
+    networkCalls?: {
+        url: string;
+        method: string;
+        duration: number;
+        success: boolean;
+    }[];
+}
+/**
+ * Retry Configuration Interface
+ */
+export interface RetryConfig {
+    maxAttempts: number;
+    delay: number;
+    backoffMultiplier?: number;
+    maxDelay?: number;
+}

package/dist/interfaces/chunks/utility.i.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Utility Type Interfaces
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Diamond Hands SDK Interfaces
+ * All TypeScript interfaces and types used in the SDK package
+ *
+ * Following the golden source pattern with organized chunks
+ */
+export * from "./chunks/config.i";
+export * from "./chunks/loan-operations.i";
+export * from "./chunks/pkp-integration.i";
+export * from "./chunks/contract-interactions.i";
+export * from "./chunks/utility.i";
+export * from "./chunks/btc.i";
+export * from "./chunks/lit-actions.i";
+export * from "./chunks/ucd-minting.i";
+export * from "./chunks/requests.i";

package/dist/interfaces/index.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Diamond Hands SDK Interfaces
+ * All TypeScript interfaces and types used in the SDK package
+ *
+ * Following the golden source pattern with organized chunks
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Configuration Types
+__exportStar(require("./chunks/config.i"), exports);
+// Loan Operation Types
+__exportStar(require("./chunks/loan-operations.i"), exports);
+// PKP Integration Types
+__exportStar(require("./chunks/pkp-integration.i"), exports);
+// Contract Interaction Types
+__exportStar(require("./chunks/contract-interactions.i"), exports);
+// Utility Types
+__exportStar(require("./chunks/utility.i"), exports);
+// Bitcoin Types
+__exportStar(require("./chunks/btc.i"), exports);
+// LIT Action Types (for compatibility with lit-ops)
+__exportStar(require("./chunks/lit-actions.i"), exports);
+// UCD Minting Types
+__exportStar(require("./chunks/ucd-minting.i"), exports);
+// Request/Response Types
+__exportStar(require("./chunks/requests.i"), exports);

package/dist/modules/contract-interaction-manager.module.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Contract Interaction Manager Module
+ * Handles all smart contract interactions for Diamond Hands Protocol
+ */
+import { ethers as ethers5 } from "ethers";
+/**
+ * Contract Transaction Result Interface
+ */
+export interface ContractTransactionResult {
+    success: boolean;
+    error?: string;
+    transactionHash?: string;
+    receipt?: ethers5.providers.TransactionReceipt;
+    gasUsed?: string;
+    events?: any[];
+}
+/**
+ * Position Details Interface
+ */
+export interface PositionDetails {
+    positionId: string;
+    pkpId: string;
+    borrower: string;
+    btcAmount: string;
+    ucdDebt: string;
+    createdAt: number;
+    lastUpdated: number;
+    isActive: boolean;
+    collateralRatio: string;
+}
+/**
+ * Contract Call Options Interface
+ */
+export interface ContractCallOptions {
+    gasLimit?: number;
+    gasPrice?: string;
+    value?: string;
+    timeout?: number;
+}
+/**
+ * Configuration for Contract Interaction Manager
+ */
+export interface ContractManagerConfig {
+    provider: ethers5.providers.JsonRpcProvider;
+    contractAddresses: {
+        positionManager: string;
+        ucdToken: string;
+        litActionValidator: string;
+        priceFeedConsumer: string;
+    };
+    debug?: boolean;
+}
+/**
+ * Contract Interaction Manager Class
+ * Manages all smart contract interactions
+ */
+export declare class ContractInteractionManager {
+    private config;
+    private positionManagerContract;
+    private initialized;
+    constructor(config: ContractManagerConfig);
+    /**
+     * Initialize the contract manager
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create position in smart contract
+     */
+    createPosition(pkpId: string, amount: string, validatorSignature: string, signer: ethers5.Wallet, options?: ContractCallOptions): Promise<ContractTransactionResult>;
+    /**
+     * Get position details
+     */
+    getPositionDetails(positionId: string): Promise<PositionDetails | null>;
+    /**
+     * Get Position Manager contract instance
+     */
+    getPositionManagerContract(): ethers5.Contract;
+    /**
+     * Cleanup manager resources
+     */
+    destroy(): Promise<void>;
+    /**
+     * Verify contracts are deployed
+     */
+    private _verifyContracts;
+}

package/dist/modules/contract-interaction-manager.module.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Contract Interaction Manager Module
+ * Handles all smart contract interactions for Diamond Hands Protocol
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractInteractionManager = void 0;
+const ethers_1 = require("ethers");
+const contract_abis_1 = require("../constants/chunks/contract-abis");
+/**
+ * Contract Interaction Manager Class
+ * Manages all smart contract interactions
+ */
+class ContractInteractionManager {
+    constructor(config) {
+        this.initialized = false;
+        this.config = config;
+        // Initialize Position Manager contract
+        this.positionManagerContract = new ethers_1.ethers.Contract(config.contractAddresses.positionManager, contract_abis_1.POSITION_MANAGER_ABI, config.provider);
+        if (this.config.debug) {
+            console.log("🔗 Contract Interaction Manager initialized");
+        }
+    }
+    /**
+     * Initialize the contract manager
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        if (this.config.debug) {
+            console.log("🚀 Initializing Contract Interaction Manager...");
+        }
+        // Verify contracts are deployed
+        await this._verifyContracts();
+        this.initialized = true;
+        if (this.config.debug) {
+            console.log("✅ Contract Interaction Manager initialized");
+        }
+    }
+    /**
+     * Create position in smart contract
+     */
+    async createPosition(pkpId, amount, validatorSignature, signer, options = {}) {
+        try {
+            if (this.config.debug) {
+                console.log("📝 Creating position in smart contract");
+                console.log(`   PKP ID: ${pkpId}`);
+                console.log(`   Amount: ${amount}`);
+            }
+            const contract = this.positionManagerContract.connect(signer);
+            // Convert PKP ID to bytes32 (ethers v5 compatible)
+            const pkpIdBytes32 = ethers_1.ethers.utils.hexZeroPad(pkpId, 32);
+            const tx = await contract.createPosition(pkpIdBytes32, amount, validatorSignature, {
+                gasLimit: options.gasLimit,
+                gasPrice: options.gasPrice,
+                value: options.value,
+            });
+            const receipt = await tx.wait();
+            if (this.config.debug) {
+                console.log("✅ Position created successfully");
+                console.log(`   Transaction Hash: ${receipt.hash}`);
+                console.log(`   Gas Used: ${receipt.gasUsed?.toString()}`);
+            }
+            return {
+                success: true,
+                transactionHash: receipt.hash,
+                receipt: receipt,
+                gasUsed: receipt.gasUsed?.toString(),
+                events: receipt.logs,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (this.config.debug) {
+                console.error("❌ Position creation failed:", errorMessage);
+            }
+            return {
+                success: false,
+                error: errorMessage,
+            };
+        }
+    }
+    /**
+     * Get position details
+     */
+    async getPositionDetails(positionId) {
+        try {
+            const position = await this.positionManagerContract.getPositionDetails(positionId);
+            return {
+                positionId: position.positionId,
+                pkpId: position.pkpId,
+                borrower: position.borrower,
+                btcAmount: position.btcAmount.toString(),
+                ucdDebt: position.ucdDebt.toString(),
+                createdAt: position.createdAt.toNumber(),
+                lastUpdated: position.lastUpdated.toNumber(),
+                isActive: position.isActive,
+                collateralRatio: position.collateralRatio.toString(),
+            };
+        }
+        catch (error) {
+            if (this.config.debug) {
+                console.error("Failed to get position details:", error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Get Position Manager contract instance
+     */
+    getPositionManagerContract() {
+        return this.positionManagerContract;
+    }
+    /**
+     * Cleanup manager resources
+     */
+    async destroy() {
+        this.initialized = false;
+        if (this.config.debug) {
+            console.log("🧹 Contract Interaction Manager cleanup complete");
+        }
+    }
+    /**
+     * Verify contracts are deployed
+     */
+    async _verifyContracts() {
+        const positionManagerCode = await this.config.provider.getCode(this.config.contractAddresses.positionManager);
+        if (positionManagerCode === "0x") {
+            throw new Error("Position Manager contract not found at specified address");
+        }
+        if (this.config.debug) {
+            console.log("✅ All contracts verified and accessible");
+        }
+    }
+}
+exports.ContractInteractionManager = ContractInteractionManager;

package/dist/modules/diamond-hands-sdk.module.d.ts

@@ -0,0 +1,109 @@
+import type { CreateLoanRequest, CreateLoanResult, DiamondHandsSDKConfig, LiquidationRequest, LoanData, LoansQuery, UCDMintRequest } from "../interfaces";
+/**
+ * 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"
+ */
+export declare class DiamondHandsSDK {
+    private litOps;
+    private config;
+    private provider;
+    private initialized;
+    private mode;
+    private serviceEndpoint;
+    constructor(config: DiamondHandsSDKConfig);
+    /**
+     * Validate configuration based on the selected mode
+     */
+    private validateConfig;
+    /**
+     * Initialize the SDK with required dependencies
+     */
+    initialize(): Promise<void>;
+    /**
+     * 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
+     */
+    createLoan(request: CreateLoanRequest): Promise<CreateLoanResult>;
+    /**
+     * Create loan in standalone mode - uses LitOps directly
+     */
+    private createLoanStandalone;
+    /**
+     * Create loan in service mode - calls lit-ops-server
+     */
+    private createLoanService;
+    /**
+     * Setup contract wallet for Ethereum transactions
+     */
+    private setupContractWallet;
+    /**
+     * Create PKP with retry logic for LIT Protocol network issues
+     */
+    private createPKPWithRetry;
+    /**
+     * Process loan creation after PKP is created - handle signature extraction and contract calls
+     */
+    private processLoanCreation;
+    /**
+     * Get single loan by vault address
+     */
+    getLoan(vaultAddress: string): Promise<LoanData | null>;
+    /**
+     * Get loans by various criteria
+     */
+    getLoans(query: LoansQuery): Promise<LoanData[]>;
+    /**
+     * Get all positions for a user
+     */
+    getUserPositions(userAddress: string): Promise<LoanData[]>;
+    /**
+     * Get position details by PKP ID
+     */
+    getPositionByPKP(pkpId: string): Promise<LoanData | 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
+     */
+    getPKPLoanParams(pkpId: string): Promise<{
+        amount: number;
+        requestedCollateralRatio: number;
+        selectedTerm: number;
+    } | null>;
+    /**
+     * Get complete PKP position data by PKP ID
+     * This provides all stored PKP position information in one call
+     */
+    getPKPPositionData(pkpId: string): Promise<{
+        positionId: string;
+        borrower: string;
+        amount: number;
+        requestedCollateralRatio: number;
+        selectedTerm: number;
+        createdAt: number;
+        isActive: boolean;
+    } | null>;
+    /**
+     * Request UCD minting for a loan
+     */
+    requestMintUCD(request: UCDMintRequest): Promise<boolean>;
+    /**
+     * Request loan liquidation
+     */
+    requestLiquidation(request: LiquidationRequest): Promise<boolean>;
+    /**
+     * Cleanup SDK resources
+     */
+    destroy(): Promise<void>;
+    private ensureInitialized;
+}