@arkade-os/boltz-swap 0.1.5 → 0.1.8

package/README.md

@@ -50,6 +50,49 @@ const arkadeLightning = new ArkadeLightning({
 });
 ```
 
+## Wallet class Compatibility
+
+This library supports both wallet interface patterns:
+
+### Wallet (with optional nested identity and providers)
+
+```typescript
+import { Wallet } from '@arkade-os/sdk';
+
+const wallet = await Wallet.create({
+  identity,
+  arkServerUrl: 'https://mutinynet.arkade.sh',
+});
+
+// Wallet may have built-in providers
+const arkadeLightning = new ArkadeLightning({
+  wallet,
+  swapProvider,
+  // arkProvider and indexerProvider can be provided here if wallet doesn't have them
+});
+```
+
+### ServiceWorkerWallet (legacy interface)
+
+```typescript
+import { RestArkProvider, RestIndexerProvider } from '@arkade-os/sdk';
+
+// ServiceWorkerWallet has identity methods spread directly (no nested identity)
+const serviceWorkerWallet = new ServiceWorkerWallet(serviceWorker);
+await serviceWorkerWallet.init({
+  privateKey: 'your_private_key_hex',
+  arkServerUrl: 'https://ark.example.com'
+});
+
+// Must provide external providers for ServiceWorkerWallet (it doesn't have them)
+const arkadeLightning = new ArkadeLightning({
+  wallet: serviceWorkerWallet,
+  arkProvider: new RestArkProvider('https://ark.example.com'),
+  indexerProvider: new RestIndexerProvider('https://indexer.example.com'),
+  swapProvider,
+});
+```
+
 ## Storage
 
 By default this library doesn't store pending swaps.

package/dist/index.cjs

@@ -119,6 +119,11 @@ var TransactionRefundedError = class extends SwapError {
 var import_sdk = require("@arkade-os/sdk");
 var import_sha2 = require("@noble/hashes/sha2");
 var import_base = require("@scure/base");
+
+// src/types.ts
+var isWalletWithNestedIdentity = (w) => !!w.identity && typeof w.identity?.xOnlyPublicKey === "function";
+
+// src/arkade-lightning.ts
 var import_utils = require("@noble/hashes/utils");
 var import_btc_signer = require("@scure/btc-signer");
 var import_legacy = require("@noble/hashes/legacy");
@@ -143,6 +148,26 @@ var getInvoicePaymentHash = (invoice) => {
 };
 
 // src/arkade-lightning.ts
+function getIdentity(wallet) {
+  if (isWalletWithNestedIdentity(wallet)) {
+    return wallet.identity;
+  }
+  return wallet;
+}
+function getXOnlyPublicKey(wallet) {
+  return getIdentity(wallet).xOnlyPublicKey();
+}
+function getSignerSession(wallet) {
+  const identity = getIdentity(wallet);
+  const signerSession = identity?.signerSession;
+  if (typeof signerSession === "function") {
+    return signerSession();
+  }
+  return signerSession;
+}
+async function signTransaction(wallet, tx, inputIndexes) {
+  return getIdentity(wallet).sign(tx, inputIndexes);
+}
 var ArkadeLightning = class {
   wallet;
   arkProvider;
@@ -151,14 +176,16 @@ var ArkadeLightning = class {
   indexerProvider;
   constructor(config) {
     if (!config.wallet) throw new Error("Wallet is required.");
-    if (!config.arkProvider) throw new Error("Ark provider is required.");
     if (!config.swapProvider) throw new Error("Swap provider is required.");
-    if (!config.indexerProvider) throw new Error("Indexer provider is required.");
     this.wallet = config.wallet;
-    this.arkProvider = config.arkProvider;
+    const arkProvider = config.wallet.arkProvider ?? config.arkProvider;
+    if (!arkProvider) throw new Error("Ark provider is required either in wallet or config.");
+    this.arkProvider = arkProvider;
+    const indexerProvider = config.wallet.indexerProvider ?? config.indexerProvider;
+    if (!indexerProvider) throw new Error("Indexer provider is required either in wallet or config.");
+    this.indexerProvider = indexerProvider;
     this.swapProvider = config.swapProvider;
     this.storageProvider = config.storageProvider ?? null;
-    this.indexerProvider = config.indexerProvider;
   }
   // receive from lightning = reverse submarine swap
   //
@@ -193,10 +220,10 @@ var ArkadeLightning = class {
   async sendLightningPayment(args) {
     return new Promise((resolve, reject) => {
       this.createSubmarineSwap(args).then((pendingSwap) => {
-        if (args.maxFeeSats) {
-          const invoiceAmount = decodeInvoice(args.invoice).amountSats;
+        if (args.maxFeeSats != null) {
+          const invoiceAmount = decodeInvoice(args.invoice).amountSats ?? 0;
           const fees = pendingSwap.response.expectedAmount - invoiceAmount;
-          if (fees > args.maxFeeSats) {
+          if (invoiceAmount > 0 && fees > args.maxFeeSats) {
             reject(new SwapError({ message: `Swap fees ${fees} exceed max allowed ${args.maxFeeSats}` }));
           }
         }
@@ -222,7 +249,7 @@ var ArkadeLightning = class {
   }
   // create submarine swap
   async createSubmarineSwap(args) {
-    const refundPublicKey = import_base.hex.encode(this.wallet.xOnlyPublicKey());
+    const refundPublicKey = import_base.hex.encode(getXOnlyPublicKey(this.wallet));
     if (!refundPublicKey) throw new SwapError({ message: "Failed to get refund public key from wallet" });
     const invoice = args.invoice;
     if (!invoice) throw new SwapError({ message: "Invoice is required" });
@@ -244,7 +271,7 @@ var ArkadeLightning = class {
   // create reverse submarine swap
   async createReverseSwap(args) {
     if (args.amount <= 0) throw new SwapError({ message: "Amount must be greater than 0" });
-    const claimPublicKey = import_base.hex.encode(this.wallet.xOnlyPublicKey());
+    const claimPublicKey = import_base.hex.encode(getXOnlyPublicKey(this.wallet));
     if (!claimPublicKey) throw new SwapError({ message: "Failed to get claim public key from wallet" });
     const preimage = (0, import_utils.randomBytes)(32);
     const preimageHash = import_base.hex.encode((0, import_sha2.sha256)(preimage));
@@ -271,7 +298,7 @@ var ArkadeLightning = class {
     const preimage = import_base.hex.decode(pendingSwap.preimage);
     const aspInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
-    let receiverXOnlyPublicKey = this.wallet.xOnlyPublicKey();
+    let receiverXOnlyPublicKey = getXOnlyPublicKey(this.wallet);
     if (receiverXOnlyPublicKey.length == 33) {
       receiverXOnlyPublicKey = receiverXOnlyPublicKey.slice(1);
     } else if (receiverXOnlyPublicKey.length !== 32) {
@@ -302,13 +329,13 @@ var ArkadeLightning = class {
     const vhtlcIdentity = {
       sign: async (tx, inputIndexes) => {
         const cpy = tx.clone();
-        let signedTx = await this.wallet.sign(cpy, inputIndexes);
+        let signedTx = await signTransaction(this.wallet, cpy, inputIndexes);
         signedTx = import_btc_signer.Transaction.fromPSBT(signedTx.toPSBT(), { allowUnknown: true });
         (0, import_sdk.setArkPsbtField)(signedTx, 0, import_sdk.ConditionWitness, [preimage]);
         return signedTx;
       },
       xOnlyPublicKey: receiverXOnlyPublicKey,
-      signerSession: this.wallet.signerSession
+      signerSession: getSignerSession(this.wallet)
     };
     const serverUnrollScript = import_sdk.CSVMultisigTapscript.encode({
       pubkeys: [serverXOnlyPublicKey],
@@ -360,7 +387,7 @@ var ArkadeLightning = class {
     const aspInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
     if (!address) throw new Error("Failed to get ark address from service worker wallet");
-    let receiverXOnlyPublicKey = this.wallet.xOnlyPublicKey();
+    let receiverXOnlyPublicKey = getXOnlyPublicKey(this.wallet);
     if (receiverXOnlyPublicKey.length == 33) {
       receiverXOnlyPublicKey = receiverXOnlyPublicKey.slice(1);
     } else if (receiverXOnlyPublicKey.length !== 32) {
@@ -376,7 +403,7 @@ var ArkadeLightning = class {
       network: aspInfo.network,
       preimageHash: import_base.hex.decode(getInvoicePaymentHash(pendingSwap.request.invoice)),
       receiverPubkey: pendingSwap.response.claimPublicKey,
-      senderPubkey: import_base.hex.encode(this.wallet.xOnlyPublicKey()),
+      senderPubkey: import_base.hex.encode(getXOnlyPublicKey(this.wallet)),
       serverPubkey: aspInfo.signerPubkey,
       timeoutBlockHeights: pendingSwap.response.timeoutBlockHeights
     });
@@ -392,11 +419,11 @@ var ArkadeLightning = class {
     const vhtlcIdentity = {
       sign: async (tx, inputIndexes) => {
         const cpy = tx.clone();
-        let signedTx = await this.wallet.sign(cpy, inputIndexes);
+        let signedTx = await signTransaction(this.wallet, cpy, inputIndexes);
         return import_btc_signer.Transaction.fromPSBT(signedTx.toPSBT(), { allowUnknown: true });
       },
       xOnlyPublicKey: receiverXOnlyPublicKey,
-      signerSession: this.wallet.signerSession
+      signerSession: getSignerSession(this.wallet)
     };
     const serverUnrollScript = import_sdk.CSVMultisigTapscript.encode({
       pubkeys: [serverXOnlyPublicKey],
@@ -490,21 +517,27 @@ var ArkadeLightning = class {
    */
   async waitForSwapSettlement(pendingSwap) {
     return new Promise((resolve, reject) => {
+      let isResolved = false;
       const onStatusUpdate = async (status) => {
+        if (isResolved) return;
         switch (status) {
           case "swap.expired":
+            isResolved = true;
             this.storageProvider?.savePendingSubmarineSwap({ ...pendingSwap, status });
             reject(new SwapExpiredError({ isRefundable: true, pendingSwap }));
             break;
           case "invoice.failedToPay":
+            isResolved = true;
             this.storageProvider?.savePendingSubmarineSwap({ ...pendingSwap, status });
             reject(new InvoiceFailedToPayError({ isRefundable: true, pendingSwap }));
             break;
           case "transaction.lockupFailed":
+            isResolved = true;
             this.storageProvider?.savePendingSubmarineSwap({ ...pendingSwap, status });
             reject(new TransactionLockupFailedError({ isRefundable: true, pendingSwap }));
             break;
           case "transaction.claimed": {
+            isResolved = true;
             const { preimage } = await this.swapProvider.getSwapPreimage(pendingSwap.response.id);
             this.storageProvider?.savePendingSubmarineSwap({ ...pendingSwap, preimage, status });
             resolve({ preimage });
@@ -515,7 +548,12 @@ var ArkadeLightning = class {
             break;
         }
       };
-      this.swapProvider.monitorSwap(pendingSwap.response.id, onStatusUpdate);
+      this.swapProvider.monitorSwap(pendingSwap.response.id, onStatusUpdate).catch((error) => {
+        if (!isResolved) {
+          isResolved = true;
+          reject(error);
+        }
+      });
     });
   }
   // validators

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { IWallet, Identity, RestArkProvider, RestIndexerProvider, VHTLC } from '@arkade-os/sdk';
+import { IWallet, ArkProvider, IndexerProvider, Identity, VHTLC } from '@arkade-os/sdk';
 
 interface StorageOptions {
     storagePath?: string;
@@ -119,7 +119,13 @@ interface Vtxo {
         locktime: number;
     };
 }
-type Wallet = IWallet & Identity;
+type WalletWithNestedIdentity = IWallet & {
+    arkProvider?: ArkProvider;
+    indexerProvider?: IndexerProvider;
+    identity: Identity;
+};
+type ServiceWorkerWallet = IWallet & Identity;
+type Wallet = WalletWithNestedIdentity | ServiceWorkerWallet;
 type Network = 'bitcoin' | 'mutinynet' | 'regtest' | 'testnet';
 interface CreateLightningInvoiceRequest {
     amount: number;
@@ -163,9 +169,9 @@ interface RefundHandler {
 }
 interface ArkadeLightningConfig {
     wallet: Wallet;
-    arkProvider: RestArkProvider;
+    arkProvider?: ArkProvider;
     swapProvider: BoltzSwapProvider;
-    indexerProvider: RestIndexerProvider;
+    indexerProvider?: IndexerProvider;
     feeConfig?: Partial<FeeConfig>;
     refundHandler?: RefundHandler;
     storageProvider?: StorageProvider | null;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { IWallet, Identity, RestArkProvider, RestIndexerProvider, VHTLC } from '@arkade-os/sdk';
+import { IWallet, ArkProvider, IndexerProvider, Identity, VHTLC } from '@arkade-os/sdk';
 
 interface StorageOptions {
     storagePath?: string;
@@ -119,7 +119,13 @@ interface Vtxo {
         locktime: number;
     };
 }
-type Wallet = IWallet & Identity;
+type WalletWithNestedIdentity = IWallet & {
+    arkProvider?: ArkProvider;
+    indexerProvider?: IndexerProvider;
+    identity: Identity;
+};
+type ServiceWorkerWallet = IWallet & Identity;
+type Wallet = WalletWithNestedIdentity | ServiceWorkerWallet;
 type Network = 'bitcoin' | 'mutinynet' | 'regtest' | 'testnet';
 interface CreateLightningInvoiceRequest {
     amount: number;
@@ -163,9 +169,9 @@ interface RefundHandler {
 }
 interface ArkadeLightningConfig {
     wallet: Wallet;
-    arkProvider: RestArkProvider;
+    arkProvider?: ArkProvider;
     swapProvider: BoltzSwapProvider;
-    indexerProvider: RestIndexerProvider;
+    indexerProvider?: IndexerProvider;
     feeConfig?: Partial<FeeConfig>;
     refundHandler?: RefundHandler;
     storageProvider?: StorageProvider | null;

package/dist/index.js

@@ -77,6 +77,11 @@ import {
 } from "@arkade-os/sdk";
 import { sha256 } from "@noble/hashes/sha2";
 import { base64, hex } from "@scure/base";
+
+// src/types.ts
+var isWalletWithNestedIdentity = (w) => !!w.identity && typeof w.identity?.xOnlyPublicKey === "function";
+
+// src/arkade-lightning.ts
 import { randomBytes } from "@noble/hashes/utils";
 import { Transaction } from "@scure/btc-signer";
 import { ripemd160 } from "@noble/hashes/legacy";
@@ -101,6 +106,26 @@ var getInvoicePaymentHash = (invoice) => {
 };
 
 // src/arkade-lightning.ts
+function getIdentity(wallet) {
+  if (isWalletWithNestedIdentity(wallet)) {
+    return wallet.identity;
+  }
+  return wallet;
+}
+function getXOnlyPublicKey(wallet) {
+  return getIdentity(wallet).xOnlyPublicKey();
+}
+function getSignerSession(wallet) {
+  const identity = getIdentity(wallet);
+  const signerSession = identity?.signerSession;
+  if (typeof signerSession === "function") {
+    return signerSession();
+  }
+  return signerSession;
+}
+async function signTransaction(wallet, tx, inputIndexes) {
+  return getIdentity(wallet).sign(tx, inputIndexes);
+}
 var ArkadeLightning = class {
   wallet;
   arkProvider;
@@ -109,14 +134,16 @@ var ArkadeLightning = class {
   indexerProvider;
   constructor(config) {
     if (!config.wallet) throw new Error("Wallet is required.");
-    if (!config.arkProvider) throw new Error("Ark provider is required.");
     if (!config.swapProvider) throw new Error("Swap provider is required.");
-    if (!config.indexerProvider) throw new Error("Indexer provider is required.");
     this.wallet = config.wallet;
-    this.arkProvider = config.arkProvider;
+    const arkProvider = config.wallet.arkProvider ?? config.arkProvider;
+    if (!arkProvider) throw new Error("Ark provider is required either in wallet or config.");
+    this.arkProvider = arkProvider;
+    const indexerProvider = config.wallet.indexerProvider ?? config.indexerProvider;
+    if (!indexerProvider) throw new Error("Indexer provider is required either in wallet or config.");
+    this.indexerProvider = indexerProvider;
     this.swapProvider = config.swapProvider;
     this.storageProvider = config.storageProvider ?? null;
-    this.indexerProvider = config.indexerProvider;
   }
   // receive from lightning = reverse submarine swap
   //
@@ -151,10 +178,10 @@ var ArkadeLightning = class {
   async sendLightningPayment(args) {
     return new Promise((resolve, reject) => {
       this.createSubmarineSwap(args).then((pendingSwap) => {
-        if (args.maxFeeSats) {
-          const invoiceAmount = decodeInvoice(args.invoice).amountSats;
+        if (args.maxFeeSats != null) {
+          const invoiceAmount = decodeInvoice(args.invoice).amountSats ?? 0;
           const fees = pendingSwap.response.expectedAmount - invoiceAmount;
-          if (fees > args.maxFeeSats) {
+          if (invoiceAmount > 0 && fees > args.maxFeeSats) {
             reject(new SwapError({ message: `Swap fees ${fees} exceed max allowed ${args.maxFeeSats}` }));
           }
         }
@@ -180,7 +207,7 @@ var ArkadeLightning = class {
   }
   // create submarine swap
   async createSubmarineSwap(args) {
-    const refundPublicKey = hex.encode(this.wallet.xOnlyPublicKey());
+    const refundPublicKey = hex.encode(getXOnlyPublicKey(this.wallet));
     if (!refundPublicKey) throw new SwapError({ message: "Failed to get refund public key from wallet" });
     const invoice = args.invoice;
     if (!invoice) throw new SwapError({ message: "Invoice is required" });
@@ -202,7 +229,7 @@ var ArkadeLightning = class {
   // create reverse submarine swap
   async createReverseSwap(args) {
     if (args.amount <= 0) throw new SwapError({ message: "Amount must be greater than 0" });
-    const claimPublicKey = hex.encode(this.wallet.xOnlyPublicKey());
+    const claimPublicKey = hex.encode(getXOnlyPublicKey(this.wallet));
     if (!claimPublicKey) throw new SwapError({ message: "Failed to get claim public key from wallet" });
     const preimage = randomBytes(32);
     const preimageHash = hex.encode(sha256(preimage));
@@ -229,7 +256,7 @@ var ArkadeLightning = class {
     const preimage = hex.decode(pendingSwap.preimage);
     const aspInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
-    let receiverXOnlyPublicKey = this.wallet.xOnlyPublicKey();
+    let receiverXOnlyPublicKey = getXOnlyPublicKey(this.wallet);
     if (receiverXOnlyPublicKey.length == 33) {
       receiverXOnlyPublicKey = receiverXOnlyPublicKey.slice(1);
     } else if (receiverXOnlyPublicKey.length !== 32) {
@@ -260,13 +287,13 @@ var ArkadeLightning = class {
     const vhtlcIdentity = {
       sign: async (tx, inputIndexes) => {
         const cpy = tx.clone();
-        let signedTx = await this.wallet.sign(cpy, inputIndexes);
+        let signedTx = await signTransaction(this.wallet, cpy, inputIndexes);
         signedTx = Transaction.fromPSBT(signedTx.toPSBT(), { allowUnknown: true });
         setArkPsbtField(signedTx, 0, ConditionWitness, [preimage]);
         return signedTx;
       },
       xOnlyPublicKey: receiverXOnlyPublicKey,
-      signerSession: this.wallet.signerSession
+      signerSession: getSignerSession(this.wallet)
     };
     const serverUnrollScript = CSVMultisigTapscript.encode({
       pubkeys: [serverXOnlyPublicKey],
@@ -318,7 +345,7 @@ var ArkadeLightning = class {
     const aspInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
     if (!address) throw new Error("Failed to get ark address from service worker wallet");
-    let receiverXOnlyPublicKey = this.wallet.xOnlyPublicKey();
+    let receiverXOnlyPublicKey = getXOnlyPublicKey(this.wallet);
     if (receiverXOnlyPublicKey.length == 33) {
       receiverXOnlyPublicKey = receiverXOnlyPublicKey.slice(1);
     } else if (receiverXOnlyPublicKey.length !== 32) {
@@ -334,7 +361,7 @@ var ArkadeLightning = class {
       network: aspInfo.network,
       preimageHash: hex.decode(getInvoicePaymentHash(pendingSwap.request.invoice)),
       receiverPubkey: pendingSwap.response.claimPublicKey,
-      senderPubkey: hex.encode(this.wallet.xOnlyPublicKey()),
+      senderPubkey: hex.encode(getXOnlyPublicKey(this.wallet)),
       serverPubkey: aspInfo.signerPubkey,
       timeoutBlockHeights: pendingSwap.response.timeoutBlockHeights
     });
@@ -350,11 +377,11 @@ var ArkadeLightning = class {
     const vhtlcIdentity = {
       sign: async (tx, inputIndexes) => {
         const cpy = tx.clone();
-        let signedTx = await this.wallet.sign(cpy, inputIndexes);
+        let signedTx = await signTransaction(this.wallet, cpy, inputIndexes);
         return Transaction.fromPSBT(signedTx.toPSBT(), { allowUnknown: true });
       },
       xOnlyPublicKey: receiverXOnlyPublicKey,
-      signerSession: this.wallet.signerSession
+      signerSession: getSignerSession(this.wallet)
     };
     const serverUnrollScript = CSVMultisigTapscript.encode({
       pubkeys: [serverXOnlyPublicKey],
@@ -448,21 +475,27 @@ var ArkadeLightning = class {
    */
   async waitForSwapSettlement(pendingSwap) {
     return new Promise((resolve, reject) => {
+      let isResolved = false;
       const onStatusUpdate = async (status) => {
+        if (isResolved) return;
         switch (status) {
           case "swap.expired":
+            isResolved = true;
             this.storageProvider?.savePendingSubmarineSwap({ ...pendingSwap, status });
             reject(new SwapExpiredError({ isRefundable: true, pendingSwap }));
             break;
           case "invoice.failedToPay":
+            isResolved = true;
             this.storageProvider?.savePendingSubmarineSwap({ ...pendingSwap, status });
             reject(new InvoiceFailedToPayError({ isRefundable: true, pendingSwap }));
             break;
           case "transaction.lockupFailed":
+            isResolved = true;
             this.storageProvider?.savePendingSubmarineSwap({ ...pendingSwap, status });
             reject(new TransactionLockupFailedError({ isRefundable: true, pendingSwap }));
             break;
           case "transaction.claimed": {
+            isResolved = true;
             const { preimage } = await this.swapProvider.getSwapPreimage(pendingSwap.response.id);
             this.storageProvider?.savePendingSubmarineSwap({ ...pendingSwap, preimage, status });
             resolve({ preimage });
@@ -473,7 +506,12 @@ var ArkadeLightning = class {
             break;
         }
       };
-      this.swapProvider.monitorSwap(pendingSwap.response.id, onStatusUpdate);
+      this.swapProvider.monitorSwap(pendingSwap.response.id, onStatusUpdate).catch((error) => {
+        if (!isResolved) {
+          isResolved = true;
+          reject(error);
+        }
+      });
     });
   }
   // validators

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/boltz-swap",
-  "version": "0.1.5",
+  "version": "0.1.8",
   "type": "module",
   "description": "A production-ready TypeScript package that brings Boltz submarine-swaps to Arkade.",
   "main": "./dist/index.js",