@arkade-os/skill 0.1.2 → 0.1.4

package/dist/cjs/skills/lendaswap.js

@@ -2,18 +2,15 @@
 /**
  * LendaSwapSkill - Swap USDC/USDT from/to Arkade via LendaSwap.
  *
- * This skill provides stablecoin swap capabilities for Arkade wallets
- * using the LendaSwap SDK for non-custodial BTC/stablecoin exchanges.
+ * Uses the @lendasat/lendaswap-sdk-pure SDK for non-custodial
+ * BTC/stablecoin atomic swaps via HTLCs.
  *
  * @module skills/lendaswap
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LendaSwapSkill = void 0;
 exports.createLendaSwapSkill = createLendaSwapSkill;
-/**
- * Default LendaSwap API URL.
- */
-const DEFAULT_API_URL = "https://apilendaswap.lendasat.com/";
+const lendaswap_sdk_pure_1 = require("@lendasat/lendaswap-sdk-pure");
 /**
  * Token decimals for stablecoins.
  */
@@ -25,389 +22,325 @@ const TOKEN_DECIMALS = {
     usdt_eth: 6,
     usdt_arb: 6,
 };
-function parseExpiry(raw, fallbackMs) {
-    if (raw === null || raw === undefined) {
-        return new Date(Date.now() + fallbackMs);
-    }
-    if (typeof raw === "string") {
-        const parsed = new Date(raw);
-        if (!Number.isNaN(parsed.getTime())) {
-            return parsed;
-        }
-    }
-    if (typeof raw === "number") {
-        const ms = raw < 1000000000000 ? raw * 1000 : raw;
-        return new Date(ms);
+/**
+ * Map SDK swap status to our simplified status.
+ */
+function mapSwapStatus(sdkStatus) {
+    switch (sdkStatus) {
+        case "pending":
+            return "pending";
+        case "clientfundingseen":
+        case "clientfunded":
+            return "funded";
+        case "serverfunded":
+        case "clientredeeming":
+            return "processing";
+        case "clientredeemed":
+        case "serverredeemed":
+        case "clientredeemedandclientrefunded":
+            return "completed";
+        case "expired":
+        case "clientfundedtoolate":
+            return "expired";
+        case "clientrefunded":
+        case "clientfundedserverrefunded":
+        case "clientrefundedserverfunded":
+        case "clientrefundedserverrefunded":
+            return "refunded";
+        case "clientinvalidfunded":
+            return "failed";
+        default:
+            return "pending";
     }
-    return new Date(Date.now() + fallbackMs);
+}
+/**
+ * Check if a status is terminal (no longer active).
+ */
+function isTerminalStatus(status) {
+    return (status === "completed" ||
+        status === "expired" ||
+        status === "refunded" ||
+        status === "failed");
 }
 /**
  * LendaSwapSkill provides stablecoin swap capabilities for Arkade wallets
- * using the LendaSwap SDK.
- *
- * This skill enables:
- * - Swapping BTC from Arkade to USDC/USDT on Polygon, Ethereum, or Arbitrum
- * - Receiving USDC/USDT and converting to BTC in your Arkade wallet
+ * using the LendaSwap SDK for non-custodial atomic swaps.
  *
  * @example
  * ```typescript
- * import { Wallet, SingleKey } from "@arkade-os/sdk";
- * import { LendaSwapSkill } from "@arkade-os/skill";
- *
- * // Create a wallet
- * const wallet = await Wallet.create({
- *   identity: SingleKey.fromHex(privateKeyHex),
- *   arkServerUrl: "https://arkade.computer",
- * });
- *
- * // Create the LendaSwap skill
  * const lendaswap = new LendaSwapSkill({ wallet });
  *
- * // Get a quote for BTC to USDC
+ * // Get a quote
  * const quote = await lendaswap.getQuoteBtcToStablecoin(100000, "usdc_pol");
- * console.log("You'll receive:", quote.targetAmount, "USDC");
  *
- * // Execute the swap
+ * // Create a swap (BTC → USDC)
  * const result = await lendaswap.swapBtcToStablecoin({
  *   targetAddress: "0x...",
  *   targetToken: "usdc_pol",
  *   targetChain: "polygon",
  *   sourceAmount: 100000,
  * });
- * console.log("Swap created:", result.swapId);
+ *
+ * // Fund the VHTLC address from your Arkade wallet, then claim
+ * const claim = await lendaswap.claimSwap(result.swapId);
  * ```
  */
 class LendaSwapSkill {
-    /**
-     * Creates a new LendaSwapSkill instance.
-     *
-     * @param config - Configuration options
-     */
     constructor(config) {
         this.name = "lendaswap";
         this.description = "Swap USDC/USDT from/to Arkade via LendaSwap non-custodial exchange";
-        this.version = "1.0.0";
-        this.swapStorage = new Map();
+        this.version = "2.0.0";
+        this.client = null;
         this.wallet = config.wallet;
-        this.apiUrl = config.apiUrl || DEFAULT_API_URL;
-        this.apiKey = config.apiKey;
         this.referralCode = config.referralCode;
+        this.config = config;
     }
     /**
-     * Check if the skill is available and properly configured.
+     * Get or create the LendaSwap SDK client (lazy initialization).
      */
+    async getClient() {
+        if (this.client)
+            return this.client;
+        const builder = lendaswap_sdk_pure_1.Client.builder()
+            .withSignerStorage(this.config.walletStorage || new lendaswap_sdk_pure_1.InMemoryWalletStorage())
+            .withSwapStorage(this.config.swapStorage || new lendaswap_sdk_pure_1.InMemorySwapStorage());
+        if (this.config.apiUrl) {
+            builder.withBaseUrl(this.config.apiUrl);
+        }
+        if (this.config.apiKey) {
+            builder.withApiKey(this.config.apiKey);
+        }
+        if (this.config.esploraUrl) {
+            builder.withEsploraUrl(this.config.esploraUrl);
+        }
+        if (this.config.arkadeServerUrl) {
+            builder.withArkadeServerUrl(this.config.arkadeServerUrl);
+        }
+        if (this.config.mnemonic) {
+            builder.withMnemonic(this.config.mnemonic);
+        }
+        this.client = await builder.build();
+        return this.client;
+    }
     async isAvailable() {
         try {
-            const response = await this.fetchApi("/pairs");
-            return response.ok;
+            const client = await this.getClient();
+            const result = await client.healthCheck();
+            return result === "ok";
         }
         catch {
             return false;
         }
     }
     /**
-     * Get a quote for swapping BTC to stablecoins.
+     * Get the LendaSwap mnemonic for persistence across sessions.
+     */
+    async getMnemonic() {
+        const client = await this.getClient();
+        return client.getMnemonic();
+    }
+    /**
+     * Get the API version info.
      */
+    async getVersion() {
+        const client = await this.getClient();
+        return client.getVersion();
+    }
     async getQuoteBtcToStablecoin(sourceAmount, targetToken) {
-        const response = await this.fetchApi("/quote", {
-            method: "POST",
-            body: JSON.stringify({
-                from: "btc_arkade",
-                to: targetToken,
-                amount: sourceAmount,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to get quote: ${response.statusText}`);
-        }
-        const data = (await response.json());
+        const client = await this.getClient();
+        const quote = await client.getQuote("btc_arkade", targetToken, sourceAmount);
+        const rate = parseFloat(quote.exchange_rate);
+        const netSats = sourceAmount - quote.protocol_fee - quote.network_fee;
+        const targetAmount = (netSats / 1e8) * rate;
         return {
             sourceToken: "btc_arkade",
             targetToken,
             sourceAmount,
-            targetAmount: data.targetAmount,
-            exchangeRate: data.exchangeRate,
+            targetAmount,
+            exchangeRate: rate,
             fee: {
-                amount: data.fee?.amount || 0,
-                percentage: data.fee?.percentage || 0,
+                amount: quote.protocol_fee + quote.network_fee,
+                percentage: quote.protocol_fee_rate * 100,
             },
-            expiresAt: parseExpiry(data.expiresAt, 60000),
+            expiresAt: new Date(Date.now() + 60000),
         };
     }
-    /**
-     * Get a quote for swapping stablecoins to BTC.
-     */
     async getQuoteStablecoinToBtc(sourceAmount, sourceToken) {
-        const response = await this.fetchApi("/quote", {
-            method: "POST",
-            body: JSON.stringify({
-                from: sourceToken,
-                to: "btc_arkade",
-                amount: sourceAmount,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to get quote: ${response.statusText}`);
-        }
-        const data = (await response.json());
+        const client = await this.getClient();
+        const quote = await client.getQuote(sourceToken, "btc_arkade", sourceAmount);
+        const rate = parseFloat(quote.exchange_rate);
+        const grossSats = (sourceAmount / rate) * 1e8;
+        const targetAmount = grossSats - quote.protocol_fee - quote.network_fee;
         return {
             sourceToken,
             targetToken: "btc_arkade",
             sourceAmount,
-            targetAmount: data.targetAmount,
-            exchangeRate: data.exchangeRate,
+            targetAmount: Math.max(0, Math.floor(targetAmount)),
+            exchangeRate: rate,
             fee: {
-                amount: data.fee?.amount || 0,
-                percentage: data.fee?.percentage || 0,
+                amount: quote.protocol_fee + quote.network_fee,
+                percentage: quote.protocol_fee_rate * 100,
             },
-            expiresAt: parseExpiry(data.expiresAt, 60000),
+            expiresAt: new Date(Date.now() + 60000),
         };
     }
-    /**
-     * Swap BTC from Arkade to stablecoins on EVM.
-     */
     async swapBtcToStablecoin(params) {
-        const arkAddress = await this.wallet.getAddress();
-        const response = await this.fetchApi("/swap/btc-to-evm", {
-            method: "POST",
-            body: JSON.stringify({
-                sourceAddress: arkAddress,
-                targetAddress: params.targetAddress,
-                targetToken: params.targetToken,
-                targetChain: params.targetChain,
-                sourceAmount: params.sourceAmount,
-                targetAmount: params.targetAmount,
-                referralCode: params.referralCode || this.referralCode,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to create swap: ${response.statusText}`);
-        }
-        const data = (await response.json());
-        const resolvedSourceAmount = params.sourceAmount ?? data.sourceAmount ?? 0;
-        // Store swap locally
-        const storedSwap = {
-            swapId: data.swapId,
-            direction: "btc_to_stablecoin",
-            status: "awaiting_funding",
-            sourceToken: "btc_arkade",
+        const client = await this.getClient();
+        const result = await client.createArkadeToEvmSwap({
+            targetAddress: params.targetAddress,
             targetToken: params.targetToken,
-            sourceAmount: resolvedSourceAmount,
-            targetAmount: data.targetAmount || 0,
-            exchangeRate: data.exchangeRate || 0,
-            createdAt: Date.now(),
-            response: data,
-        };
-        this.swapStorage.set(data.swapId, storedSwap);
+            targetChain: params.targetChain,
+            sourceAmount: params.sourceAmount,
+            targetAmount: params.targetAmount,
+            referralCode: params.referralCode || this.referralCode,
+        });
+        const resp = result.response;
         return {
-            swapId: data.swapId,
-            status: "awaiting_funding",
-            sourceAmount: resolvedSourceAmount,
-            targetAmount: data.targetAmount || 0,
-            exchangeRate: data.exchangeRate || 0,
+            swapId: resp.id,
+            status: mapSwapStatus(resp.status),
+            sourceAmount: resp.source_amount,
+            targetAmount: resp.target_amount,
+            exchangeRate: 0,
             fee: {
-                amount: data.fee?.amount || 0,
-                percentage: data.fee?.percentage || 0,
+                amount: resp.fee_sats,
+                percentage: 0,
             },
-            expiresAt: new Date(data.expiresAt || Date.now() + 3600000),
+            expiresAt: new Date(resp.vhtlc_refund_locktime * 1000),
             paymentDetails: {
-                address: data.paymentAddress,
+                address: resp.htlc_address_arkade,
             },
         };
     }
-    /**
-     * Swap stablecoins from EVM to BTC on Arkade.
-     */
     async swapStablecoinToBtc(params) {
-        const arkAddress = await this.wallet.getAddress();
-        const targetAddress = params.targetAddress || arkAddress;
-        const response = await this.fetchApi("/swap/evm-to-arkade", {
-            method: "POST",
-            body: JSON.stringify({
-                sourceChain: params.sourceChain,
-                sourceToken: params.sourceToken,
-                sourceAmount: params.sourceAmount,
-                targetAddress,
-                userAddress: params.userAddress,
-                referralCode: params.referralCode || this.referralCode,
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to create swap: ${response.statusText}`);
-        }
-        const data = (await response.json());
-        // Store swap locally
-        const storedSwap = {
-            swapId: data.swapId,
-            direction: "stablecoin_to_btc",
-            status: "awaiting_funding",
+        const client = await this.getClient();
+        const arkAddress = params.targetAddress || (await this.wallet.getAddress());
+        const result = await client.createEvmToArkadeSwap({
+            sourceChain: params.sourceChain,
             sourceToken: params.sourceToken,
-            targetToken: "btc_arkade",
             sourceAmount: params.sourceAmount,
-            targetAmount: data.targetAmount || 0,
-            exchangeRate: data.exchangeRate || 0,
-            createdAt: Date.now(),
-            response: data,
-        };
-        this.swapStorage.set(data.swapId, storedSwap);
+            targetAddress: arkAddress,
+            userAddress: params.userAddress,
+            referralCode: params.referralCode || this.referralCode,
+        });
+        const resp = result.response;
         return {
-            swapId: data.swapId,
-            status: "awaiting_funding",
-            sourceAmount: params.sourceAmount,
-            targetAmount: data.targetAmount || 0,
-            exchangeRate: data.exchangeRate || 0,
+            swapId: resp.id,
+            status: mapSwapStatus(resp.status),
+            sourceAmount: resp.source_amount,
+            targetAmount: resp.target_amount,
+            exchangeRate: 0,
             fee: {
-                amount: data.fee?.amount || 0,
-                percentage: data.fee?.percentage || 0,
+                amount: resp.fee_sats,
+                percentage: 0,
             },
-            expiresAt: new Date(data.expiresAt || Date.now() + 3600000),
+            expiresAt: new Date(resp.evm_refund_locktime * 1000),
             paymentDetails: {
-                address: data.htlcAddress,
-                callData: data.fundingCallData,
+                address: resp.htlc_address_evm,
+                callData: resp.source_token_address,
             },
         };
     }
-    /**
-     * Get the status of a swap.
-     */
     async getSwapStatus(swapId) {
-        const response = await this.fetchApi(`/swap/${swapId}`);
-        if (!response.ok) {
-            throw new Error(`Failed to get swap status: ${response.statusText}`);
-        }
-        const data = (await response.json());
-        // Update local storage
-        const stored = this.swapStorage.get(swapId);
-        if (stored) {
-            stored.status = data.status;
-            stored.txid = data.txid;
-            if (data.status === "completed") {
-                stored.completedAt = Date.now();
-            }
-        }
+        const client = await this.getClient();
+        const data = await client.getSwap(swapId, { updateStorage: true });
+        const direction = data.direction === "evm_to_btc"
+            ? "stablecoin_to_btc"
+            : "btc_to_stablecoin";
+        const status = mapSwapStatus(data.status);
         return {
             id: swapId,
-            direction: data.direction || stored?.direction || "btc_to_stablecoin",
-            status: data.status,
-            sourceToken: data.sourceToken || stored?.sourceToken || "",
-            targetToken: data.targetToken || stored?.targetToken || "",
-            sourceAmount: data.sourceAmount || stored?.sourceAmount || 0,
-            targetAmount: data.targetAmount || stored?.targetAmount || 0,
-            exchangeRate: data.exchangeRate || stored?.exchangeRate || 0,
-            createdAt: new Date(data.createdAt || stored?.createdAt || Date.now()),
-            completedAt: data.completedAt ? new Date(data.completedAt) : undefined,
-            txid: data.txid,
+            direction,
+            status,
+            sourceToken: data.source_token,
+            targetToken: data.target_token,
+            sourceAmount: data.source_amount,
+            targetAmount: data.target_amount,
+            exchangeRate: 0,
+            createdAt: new Date(data.created_at),
+            completedAt: status === "completed" ? new Date() : undefined,
+            txid: ("evm_htlc_claim_txid" in data
+                ? data.evm_htlc_claim_txid
+                : undefined) ?? undefined,
         };
     }
-    /**
-     * Get pending stablecoin swaps.
-     */
     async getPendingSwaps() {
+        const client = await this.getClient();
+        const allSwaps = await client.listAllSwaps();
         const pending = [];
-        for (const [id, swap] of this.swapStorage) {
-            if (swap.status !== "completed" &&
-                swap.status !== "expired" &&
-                swap.status !== "refunded" &&
-                swap.status !== "failed") {
+        for (const stored of allSwaps) {
+            const status = mapSwapStatus(stored.response.status);
+            if (!isTerminalStatus(status)) {
                 try {
-                    const status = await this.getSwapStatus(id);
-                    pending.push(status);
+                    const info = await this.getSwapStatus(stored.swapId);
+                    pending.push(info);
                 }
                 catch {
-                    // Swap might not exist on server anymore
-                    pending.push({
-                        id,
-                        direction: swap.direction,
-                        status: swap.status,
-                        sourceToken: swap.sourceToken,
-                        targetToken: swap.targetToken,
-                        sourceAmount: swap.sourceAmount,
-                        targetAmount: swap.targetAmount,
-                        exchangeRate: swap.exchangeRate,
-                        createdAt: new Date(swap.createdAt),
-                    });
+                    pending.push(this.storedSwapToInfo(stored));
                 }
             }
         }
         return pending;
     }
-    /**
-     * Get stablecoin swap history.
-     */
     async getSwapHistory() {
-        const history = [];
-        for (const [id, swap] of this.swapStorage) {
-            history.push({
-                id,
-                direction: swap.direction,
-                status: swap.status,
-                sourceToken: swap.sourceToken,
-                targetToken: swap.targetToken,
-                sourceAmount: swap.sourceAmount,
-                targetAmount: swap.targetAmount,
-                exchangeRate: swap.exchangeRate,
-                createdAt: new Date(swap.createdAt),
-                completedAt: swap.completedAt ? new Date(swap.completedAt) : undefined,
-                txid: swap.txid,
-            });
-        }
-        return history.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        const client = await this.getClient();
+        const allSwaps = await client.listAllSwaps();
+        return allSwaps
+            .map((stored) => this.storedSwapToInfo(stored))
+            .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
     }
-    /**
-     * Get available trading pairs.
-     */
     async getAvailablePairs() {
-        const response = await this.fetchApi("/pairs");
-        if (!response.ok) {
-            throw new Error(`Failed to get pairs: ${response.statusText}`);
-        }
-        const data = (await response.json());
-        return (data.pairs || data || []).map((pair) => ({
-            from: pair.from || pair.source,
-            to: pair.to || pair.target,
-            minAmount: pair.minAmount || pair.min || 0,
-            maxAmount: pair.maxAmount || pair.max || 0,
-            feePercentage: pair.feePercentage || pair.fee || 0,
+        const client = await this.getClient();
+        const pairs = await client.getAssetPairs();
+        return pairs.map((pair) => ({
+            from: pair.source.token_id,
+            to: pair.target.token_id,
+            minAmount: 0,
+            maxAmount: 0,
+            feePercentage: 0,
         }));
     }
-    /**
-     * Claim funds from a completed swap.
-     */
     async claimSwap(swapId) {
-        const response = await this.fetchApi(`/swap/${swapId}/claim`, {
-            method: "POST",
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to claim swap: ${response.statusText}`);
-        }
-        const data = (await response.json());
-        // Update local storage
-        const stored = this.swapStorage.get(swapId);
-        if (stored) {
-            stored.status = "completed";
-            stored.completedAt = Date.now();
-            stored.txid = data.txid;
-        }
-        return { txid: data.txid };
+        const client = await this.getClient();
+        const result = await client.claim(swapId);
+        return {
+            success: result.success,
+            message: result.message,
+            txHash: result.txHash,
+            chain: result.chain,
+        };
     }
-    /**
-     * Refund an expired or failed swap.
-     */
-    async refundSwap(swapId) {
-        const response = await this.fetchApi(`/swap/${swapId}/refund`, {
-            method: "POST",
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to refund swap: ${response.statusText}`);
-        }
-        const data = (await response.json());
-        // Update local storage
-        const stored = this.swapStorage.get(swapId);
-        if (stored) {
-            stored.status = "refunded";
-            stored.txid = data.txid;
-        }
-        return { txid: data.txid };
+    async refundSwap(swapId, options) {
+        const client = await this.getClient();
+        const refundOptions = options?.destinationAddress
+            ? { destinationAddress: options.destinationAddress }
+            : undefined;
+        const result = await client.refundSwap(swapId, refundOptions);
+        return {
+            success: result.success,
+            message: result.message,
+            txId: result.txId,
+            refundAmount: result.refundAmount
+                ? Number(result.refundAmount)
+                : undefined,
+        };
+    }
+    async getEvmFundingCallData(swapId, tokenDecimals) {
+        const client = await this.getClient();
+        const data = await client.getEvmFundingCallData(swapId, tokenDecimals);
+        return {
+            approve: { to: data.approve.to, data: data.approve.data },
+            createSwap: { to: data.createSwap.to, data: data.createSwap.data },
+        };
+    }
+    async getEvmRefundCallData(swapId) {
+        const client = await this.getClient();
+        const data = await client.getEvmRefundCallData(swapId);
+        return {
+            to: data.to,
+            data: data.data,
+            timelockExpired: data.timelockExpired,
+            timelockExpiry: data.timelockExpiry,
+        };
     }
     /**
      * Get the underlying wallet instance.
@@ -422,32 +355,31 @@ class LendaSwapSkill {
         return TOKEN_DECIMALS[token] || 6;
     }
     /**
-     * Helper to fetch from LendaSwap API.
+     * Convert a StoredSwap to StablecoinSwapInfo.
      */
-    async fetchApi(path, options = {}) {
-        const url = `${this.apiUrl.replace(/\/$/, "")}${path}`;
-        const headers = {
-            "Content-Type": "application/json",
+    storedSwapToInfo(stored) {
+        const resp = stored.response;
+        const direction = resp.direction === "evm_to_btc"
+            ? "stablecoin_to_btc"
+            : "btc_to_stablecoin";
+        const status = mapSwapStatus(resp.status);
+        return {
+            id: stored.swapId,
+            direction,
+            status,
+            sourceToken: resp.source_token,
+            targetToken: resp.target_token,
+            sourceAmount: resp.source_amount,
+            targetAmount: resp.target_amount,
+            exchangeRate: 0,
+            createdAt: new Date(resp.created_at),
+            completedAt: status === "completed" ? new Date() : undefined,
         };
-        if (this.apiKey) {
-            headers["X-API-Key"] = this.apiKey;
-        }
-        return fetch(url, {
-            ...options,
-            headers: {
-                ...headers,
-                ...options.headers,
-            },
-        });
     }
 }
 exports.LendaSwapSkill = LendaSwapSkill;
 /**
  * Create a LendaSwapSkill from a wallet.
- *
- * @param wallet - The Arkade wallet to use
- * @param options - Optional configuration
- * @returns A new LendaSwapSkill instance
  */
 function createLendaSwapSkill(wallet, options) {
     return new LendaSwapSkill({