@flashnet/sdk 0.4.1 → 0.4.3

package/dist/esm/src/client/FlashnetClient.js

@@ -4,6 +4,7 @@ import { getClientEnvironmentName, resolveClientNetworkConfig, getClientNetworkC
 import { getSparkNetworkFromLegacy, getClientEnvironmentFromLegacy, Network } from '../types/index.js';
 import { generateNonce, compareDecimalStrings } from '../utils/index.js';
 import { AuthManager } from '../utils/auth.js';
+import sha256 from 'fast-sha256';
 import { getHexFromUint8Array } from '../utils/hex.js';
 import { generateConstantProductPoolInitializationIntentMessage, generatePoolInitializationIntentMessage, generatePoolConfirmInitialDepositIntentMessage, generatePoolSwapIntentMessage, generateRouteSwapIntentMessage, generateAddLiquidityIntentMessage, generateRemoveLiquidityIntentMessage, generateRegisterHostIntentMessage, generateWithdrawHostFeesIntentMessage, generateWithdrawIntegratorFeesIntentMessage, generateCreateEscrowIntentMessage, generateFundEscrowIntentMessage, generateClaimEscrowIntentMessage, generateClawbackIntentMessage } from '../utils/intents.js';
 import { getSparkNetworkFromAddress, encodeSparkAddressNew } from '../utils/spark-address.js';
@@ -364,7 +365,7 @@ class FlashnetClient {
             nonce,
         });
         // Sign intent
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         // Create pool
         const request = {
@@ -495,7 +496,7 @@ class FlashnetClient {
             totalHostFeeRateBps: params.totalHostFeeRateBps.toString(),
             nonce,
         });
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         // Create pool
         const request = {
@@ -551,7 +552,7 @@ class FlashnetClient {
             assetASparkTransferId,
             nonce,
         });
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         const request = {
             poolId,
@@ -635,7 +636,7 @@ class FlashnetClient {
             nonce,
         });
         // Sign intent
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         const request = {
             userPublicKey: this.publicKey,
@@ -771,7 +772,7 @@ class FlashnetClient {
                 defaultIntegratorFeeRateBps: params.integratorFeeRateBps?.toString(),
             });
             // Sign intent
-            const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+            const messageHash = sha256(intentMessage);
             const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
             const request = {
                 userPublicKey: this.publicKey,
@@ -870,7 +871,7 @@ class FlashnetClient {
                 nonce,
             });
             // Sign intent
-            const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+            const messageHash = sha256(intentMessage);
             const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
             const request = {
                 userPublicKey: this.publicKey,
@@ -945,7 +946,7 @@ class FlashnetClient {
             nonce,
         });
         // Sign intent
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         const request = {
             userPublicKey: this.publicKey,
@@ -979,7 +980,7 @@ class FlashnetClient {
             nonce,
         });
         // Sign intent
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         const request = {
             namespace: params.namespace,
@@ -1027,7 +1028,7 @@ class FlashnetClient {
             nonce,
         });
         // Sign intent
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         const request = {
             lpIdentityPublicKey: params.lpIdentityPublicKey,
@@ -1084,7 +1085,7 @@ class FlashnetClient {
             nonce,
         });
         // Sign intent
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         const request = {
             integratorPublicKey: this.publicKey,
@@ -1135,7 +1136,7 @@ class FlashnetClient {
             abandonConditions: params.abandonConditions || undefined,
             nonce,
         });
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         const request = {
             creatorPublicKey: this.publicKey,
@@ -1203,7 +1204,7 @@ class FlashnetClient {
             nonce,
         });
         // Sign
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         // Call API
         const request = {
@@ -1228,7 +1229,7 @@ class FlashnetClient {
             recipientPublicKey: this.publicKey,
             nonce,
         });
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         const request = {
             escrowId: params.escrowId,
@@ -1284,7 +1285,7 @@ class FlashnetClient {
             lpIdentityPublicKey: params.lpIdentityPublicKey,
             nonce,
         });
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         const request = {
             senderPublicKey: this.publicKey,
@@ -1765,7 +1766,7 @@ class FlashnetClient {
             assetBMinAmountIn: assetBMinAmountIn.toString(),
             nonce,
         });
-        const messageHash = new Uint8Array(await crypto.subtle.digest("SHA-256", intentMessage));
+        const messageHash = sha256(intentMessage);
         const signature = await this._wallet.config.signer.signMessageWithIdentityKey(messageHash, true);
         const request = {
             userPublicKey: this.publicKey,
@@ -1863,15 +1864,16 @@ class FlashnetClient {
      */
     async payLightningWithToken(options) {
         await this.ensureInitialized();
-        const { invoice, tokenAddress, maxSlippageBps = 100, // 1% default
-        maxLightningFeeSats, preferSpark = true, integratorFeeRateBps, integratorPublicKey, transferTimeoutMs = 10000, } = options;
+        const { invoice, tokenAddress, maxSlippageBps = 500, // 5% default
+        maxLightningFeeSats, preferSpark = true, integratorFeeRateBps, integratorPublicKey, transferTimeoutMs = 30000, // 30s default
+        rollbackOnFailure = false, useExistingBtcBalance = false, } = options;
         try {
             // Step 1: Get a quote for the payment
             const quote = await this.getPayLightningWithTokenQuote(invoice, tokenAddress, {
                 maxSlippageBps,
                 integratorFeeRateBps,
             });
-            // Step 2: Check balance
+            // Step 2: Check token balance (always required)
             await this.checkBalance({
                 balancesToCheck: [
                     {
@@ -1881,6 +1883,16 @@ class FlashnetClient {
                 ],
                 errorPrefix: "Insufficient token balance for Lightning payment: ",
             });
+            // Determine if we can pay immediately using existing BTC balance
+            let canPayImmediately = false;
+            if (useExistingBtcBalance) {
+                const invoiceAmountSats = await this.decodeInvoiceAmount(invoice);
+                const effectiveMaxLightningFee = maxLightningFeeSats ?? quote.estimatedLightningFee;
+                const btcNeededForPayment = invoiceAmountSats + effectiveMaxLightningFee;
+                // Check if we have enough BTC (don't throw if not, just fall back to waiting)
+                const balance = await this.getBalance();
+                canPayImmediately = balance.balance >= BigInt(btcNeededForPayment);
+            }
             // Step 3: Get pool details
             const pool = await this.getPool(quote.poolId);
             // Step 4: Determine swap direction and execute
@@ -1914,39 +1926,88 @@ class FlashnetClient {
                     error: swapResponse.error || "Swap was not accepted",
                 };
             }
-            // Step 5: Wait for the transfer to complete
-            const transferComplete = await this.waitForTransferCompletion(swapResponse.outboundTransferId, transferTimeoutMs);
-            if (!transferComplete) {
+            // Step 5: Wait for the transfer to complete (unless paying immediately with existing BTC)
+            if (!canPayImmediately) {
+                const transferComplete = await this.waitForTransferCompletion(swapResponse.outboundTransferId, transferTimeoutMs);
+                if (!transferComplete) {
+                    return {
+                        success: false,
+                        poolId: quote.poolId,
+                        tokenAmountSpent: quote.tokenAmountRequired,
+                        btcAmountReceived: swapResponse.amountOut || "0",
+                        swapTransferId: swapResponse.outboundTransferId,
+                        ammFeePaid: quote.estimatedAmmFee,
+                        error: "Transfer did not complete within timeout",
+                    };
+                }
+            }
+            // Step 6: Calculate Lightning fee limit - use the quoted estimate, not a recalculation
+            const effectiveMaxLightningFee = maxLightningFeeSats ?? quote.estimatedLightningFee;
+            // Step 7: Pay the Lightning invoice
+            const btcReceived = swapResponse.amountOut || quote.btcAmountRequired;
+            try {
+                const lightningPayment = await this._wallet.payLightningInvoice({
+                    invoice,
+                    maxFeeSats: effectiveMaxLightningFee,
+                    preferSpark,
+                });
+                return {
+                    success: true,
+                    poolId: quote.poolId,
+                    tokenAmountSpent: quote.tokenAmountRequired,
+                    btcAmountReceived: btcReceived,
+                    swapTransferId: swapResponse.outboundTransferId,
+                    lightningPaymentId: lightningPayment.id,
+                    ammFeePaid: quote.estimatedAmmFee,
+                    lightningFeePaid: effectiveMaxLightningFee,
+                };
+            }
+            catch (lightningError) {
+                // Lightning payment failed after swap succeeded
+                const lightningErrorMessage = lightningError instanceof Error
+                    ? lightningError.message
+                    : String(lightningError);
+                // Attempt rollback if requested
+                if (rollbackOnFailure) {
+                    try {
+                        const rollbackResult = await this.rollbackSwap(quote.poolId, btcReceived, tokenAddress, maxSlippageBps);
+                        if (rollbackResult.success) {
+                            return {
+                                success: false,
+                                poolId: quote.poolId,
+                                tokenAmountSpent: "0", // Rolled back
+                                btcAmountReceived: "0",
+                                swapTransferId: swapResponse.outboundTransferId,
+                                ammFeePaid: quote.estimatedAmmFee,
+                                error: `Lightning payment failed: ${lightningErrorMessage}. Funds rolled back to ${rollbackResult.tokenAmount} tokens.`,
+                            };
+                        }
+                    }
+                    catch (rollbackError) {
+                        const rollbackErrorMessage = rollbackError instanceof Error
+                            ? rollbackError.message
+                            : String(rollbackError);
+                        return {
+                            success: false,
+                            poolId: quote.poolId,
+                            tokenAmountSpent: quote.tokenAmountRequired,
+                            btcAmountReceived: btcReceived,
+                            swapTransferId: swapResponse.outboundTransferId,
+                            ammFeePaid: quote.estimatedAmmFee,
+                            error: `Lightning payment failed: ${lightningErrorMessage}. Rollback also failed: ${rollbackErrorMessage}. BTC remains in wallet.`,
+                        };
+                    }
+                }
                 return {
                     success: false,
                     poolId: quote.poolId,
                     tokenAmountSpent: quote.tokenAmountRequired,
-                    btcAmountReceived: swapResponse.amountOut || "0",
+                    btcAmountReceived: btcReceived,
                     swapTransferId: swapResponse.outboundTransferId,
                     ammFeePaid: quote.estimatedAmmFee,
-                    error: "Transfer did not complete within timeout",
+                    error: `Lightning payment failed: ${lightningErrorMessage}. BTC (${btcReceived} sats) remains in wallet.`,
                 };
             }
-            // Step 6: Calculate Lightning fee limit
-            const invoiceAmountSats = await this.decodeInvoiceAmount(invoice);
-            const effectiveMaxLightningFee = maxLightningFeeSats ??
-                Math.max(5, Math.ceil(invoiceAmountSats * 0.0017)); // 17 bps or 5 sats minimum
-            // Step 7: Pay the Lightning invoice
-            const lightningPayment = await this._wallet.payLightningInvoice({
-                invoice,
-                maxFeeSats: effectiveMaxLightningFee,
-                preferSpark,
-            });
-            return {
-                success: true,
-                poolId: quote.poolId,
-                tokenAmountSpent: quote.tokenAmountRequired,
-                btcAmountReceived: swapResponse.amountOut || quote.btcAmountRequired,
-                swapTransferId: swapResponse.outboundTransferId,
-                lightningPaymentId: lightningPayment.id,
-                ammFeePaid: quote.estimatedAmmFee,
-                lightningFeePaid: effectiveMaxLightningFee,
-            };
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1961,6 +2022,45 @@ class FlashnetClient {
             };
         }
     }
+    /**
+     * Attempt to rollback a swap by swapping BTC back to the original token
+     * @private
+     */
+    async rollbackSwap(poolId, btcAmount, tokenAddress, maxSlippageBps) {
+        const pool = await this.getPool(poolId);
+        const tokenHex = this.toHexTokenIdentifier(tokenAddress);
+        // Determine swap direction (BTC -> Token)
+        const tokenIsAssetA = pool.assetAAddress === tokenHex;
+        const assetInAddress = tokenIsAssetA
+            ? pool.assetBAddress
+            : pool.assetAAddress; // BTC
+        const assetOutAddress = tokenIsAssetA
+            ? pool.assetAAddress
+            : pool.assetBAddress; // Token
+        // Calculate expected token output and min amount with slippage
+        // For rollback, we accept more slippage since we're recovering from failure
+        const minAmountOut = "0"; // Accept any amount to ensure rollback succeeds
+        // Execute reverse swap
+        const swapResponse = await this.executeSwap({
+            poolId,
+            assetInAddress,
+            assetOutAddress,
+            amountIn: btcAmount,
+            maxSlippageBps: maxSlippageBps * 2, // Double slippage for rollback
+            minAmountOut,
+        });
+        if (!swapResponse.accepted) {
+            throw new Error(swapResponse.error || "Rollback swap not accepted");
+        }
+        // Wait for the rollback transfer
+        if (swapResponse.outboundTransferId) {
+            await this.waitForTransferCompletion(swapResponse.outboundTransferId, 30000);
+        }
+        return {
+            success: true,
+            tokenAmount: swapResponse.amountOut,
+        };
+    }
     /**
      * Find the best pool for swapping a token to BTC
      * @private