@atomiqlabs/lp-lib 12.1.0 → 13.0.0-beta.1

package/dist/swaps/{frombtc_trusted → trusted/frombtc_trusted}/FromBtcTrustedSwap.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcTrustedSwap = exports.FromBtcTrustedSwapState = void 0;
 const base_1 = require("@atomiqlabs/base");
-const FromBtcBaseSwap_1 = require("../FromBtcBaseSwap");
-const Utils_1 = require("../../utils/Utils");
+const Utils_1 = require("../../../utils/Utils");
 const crypto_1 = require("crypto");
+const SwapHandlerSwap_1 = require("../../SwapHandlerSwap");
+const SwapHandler_1 = require("../../SwapHandler");
 var FromBtcTrustedSwapState;
 (function (FromBtcTrustedSwapState) {
     FromBtcTrustedSwapState[FromBtcTrustedSwapState["DOUBLE_SPENT"] = -4] = "DOUBLE_SPENT";
@@ -18,12 +19,13 @@ var FromBtcTrustedSwapState;
     FromBtcTrustedSwapState[FromBtcTrustedSwapState["CONFIRMED"] = 4] = "CONFIRMED";
     FromBtcTrustedSwapState[FromBtcTrustedSwapState["FINISHED"] = 5] = "FINISHED";
 })(FromBtcTrustedSwapState = exports.FromBtcTrustedSwapState || (exports.FromBtcTrustedSwapState = {}));
-class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
+class FromBtcTrustedSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
     constructor(objOrChainIdentifier, swapFee, swapFeeInToken, btcAddress, inputSats, dstAddress, outputTokens, createdHeight, expiresAt, recommendedFee, refundAddress, token) {
         if (typeof (objOrChainIdentifier) === "string") {
-            super(objOrChainIdentifier, inputSats, swapFee, swapFeeInToken);
+            super(objOrChainIdentifier, swapFee, swapFeeInToken);
             this.state = FromBtcTrustedSwapState.CREATED;
             this.doubleSpent = false;
+            this.amount = inputSats;
             this.sequence = base_1.BigIntBufferUtils.fromBuffer((0, crypto_1.randomBytes)(8));
             this.btcAddress = btcAddress;
             this.dstAddress = dstAddress;
@@ -37,6 +39,7 @@ class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
         else {
             super(objOrChainIdentifier);
             this.btcAddress = objOrChainIdentifier.btcAddress;
+            this.amount = (0, Utils_1.deserializeBN)(objOrChainIdentifier.amount);
             this.sequence = (0, Utils_1.deserializeBN)(objOrChainIdentifier.sequence);
             this.dstAddress = objOrChainIdentifier.dstAddress;
             this.outputTokens = (0, Utils_1.deserializeBN)(objOrChainIdentifier.outputTokens);
@@ -57,10 +60,12 @@ class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
             this.refundTxId = objOrChainIdentifier.refundTxId;
             this.token = objOrChainIdentifier.token;
         }
+        this.type = SwapHandler_1.SwapHandlerType.FROM_BTC_TRUSTED;
     }
     serialize() {
         const partialSerialized = super.serialize();
         partialSerialized.btcAddress = this.btcAddress;
+        partialSerialized.amount = (0, Utils_1.serializeBN)(this.amount);
         partialSerialized.sequence = (0, Utils_1.serializeBN)(this.sequence);
         partialSerialized.dstAddress = this.dstAddress;
         partialSerialized.outputTokens = (0, Utils_1.serializeBN)(this.outputTokens);
@@ -82,9 +87,6 @@ class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
         partialSerialized.token = this.token;
         return partialSerialized;
     }
-    getClaimHash() {
-        return (0, crypto_1.createHash)("sha256").update(this.btcAddress).digest().toString("hex");
-    }
     getSequence() {
         return this.sequence;
     }
@@ -97,6 +99,9 @@ class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     getTotalInputAmount() {
         return this.adjustedInput || this.amount;
     }
+    getSwapFee() {
+        return { inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken };
+    }
     isFailed() {
         return this.state === FromBtcTrustedSwapState.EXPIRED || this.state === FromBtcTrustedSwapState.REFUNDED || this.state === FromBtcTrustedSwapState.DOUBLE_SPENT;
     }
@@ -106,5 +111,8 @@ class FromBtcTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     isSuccess() {
         return this.state === FromBtcTrustedSwapState.CONFIRMED;
     }
+    getIdentifierHash() {
+        return (0, crypto_1.createHash)("sha256").update(this.btcAddress).digest().toString("hex");
+    }
 }
 exports.FromBtcTrustedSwap = FromBtcTrustedSwap;

package/dist/swaps/{frombtcln_trusted → trusted/frombtcln_trusted}/FromBtcLnTrusted.d.ts

@@ -1,13 +1,12 @@
 import { Express } from "express";
-import { ClaimEvent, InitializeEvent, RefundEvent, SwapData } from "@atomiqlabs/base";
 import { FromBtcLnTrustedSwap, FromBtcLnTrustedSwapState } from "./FromBtcLnTrustedSwap";
-import { FromBtcBaseConfig } from "../FromBtcBaseSwapHandler";
-import { ISwapPrice } from "../ISwapPrice";
-import { MultichainData, SwapHandlerType } from "../SwapHandler";
-import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
-import { FromBtcLnBaseSwapHandler } from "../FromBtcLnBaseSwapHandler";
-import { ILightningWallet } from "../../wallets/ILightningWallet";
-export type SwapForGasServerConfig = FromBtcBaseConfig & {
+import { ISwapPrice } from "../../../prices/ISwapPrice";
+import { MultichainData, SwapBaseConfig, SwapHandler, SwapHandlerType } from "../../SwapHandler";
+import { IIntermediaryStorage } from "../../../storage/IIntermediaryStorage";
+import { ILightningWallet } from "../../../wallets/ILightningWallet";
+import { FromBtcAmountAssertions } from "../../assertions/FromBtcAmountAssertions";
+import { LightningAssertions } from "../../assertions/LightningAssertions";
+export type SwapForGasServerConfig = SwapBaseConfig & {
     minCltv: bigint;
     invoiceTimeoutSeconds?: number;
 };
@@ -20,12 +19,14 @@ export type FromBtcLnTrustedRequestType = {
 /**
  * Swap handler handling from BTCLN swaps using submarine swaps
  */
-export declare class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLnTrustedSwap, FromBtcLnTrustedSwapState> {
-    readonly type: SwapHandlerType;
-    readonly swapType: any;
+export declare class FromBtcLnTrusted extends SwapHandler<FromBtcLnTrustedSwap, FromBtcLnTrustedSwapState> {
+    readonly type = SwapHandlerType.FROM_BTCLN_TRUSTED;
     activeSubscriptions: Map<string, AbortController>;
     processedTxIds: Map<string, string>;
     readonly config: SwapForGasServerConfig;
+    readonly lightning: ILightningWallet;
+    readonly LightningAssertions: LightningAssertions;
+    readonly AmountAssertions: FromBtcAmountAssertions;
     constructor(storageDirectory: IIntermediaryStorage<FromBtcLnTrustedSwap>, path: string, chains: MultichainData, lightning: ILightningWallet, swapPricing: ISwapPrice, config: SwapForGasServerConfig);
     /**
      * Unsubscribe from the pending lightning network invoice
@@ -72,7 +73,4 @@ export declare class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler<FromBtcLn
     startRestServer(restServer: Express): void;
     init(): Promise<void>;
     getInfoData(): any;
-    protected processClaimEvent(chainIdentifier: string, swap: FromBtcLnTrustedSwap, event: ClaimEvent<SwapData>): Promise<void>;
-    protected processInitializeEvent(chainIdentifier: string, swap: FromBtcLnTrustedSwap, event: InitializeEvent<SwapData>): Promise<void>;
-    protected processRefundEvent(chainIdentifier: string, swap: FromBtcLnTrustedSwap, event: RefundEvent<SwapData>): Promise<void>;
 }

package/dist/swaps/{frombtcln_trusted → trusted/frombtcln_trusted}/FromBtcLnTrusted.js

@@ -3,21 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcLnTrusted = void 0;
 const crypto_1 = require("crypto");
 const FromBtcLnTrustedSwap_1 = require("./FromBtcLnTrustedSwap");
-const SwapHandler_1 = require("../SwapHandler");
-const Utils_1 = require("../../utils/Utils");
-const SchemaVerifier_1 = require("../../utils/paramcoders/SchemaVerifier");
-const PluginManager_1 = require("../../plugins/PluginManager");
-const FromBtcLnBaseSwapHandler_1 = require("../FromBtcLnBaseSwapHandler");
+const SwapHandler_1 = require("../../SwapHandler");
+const Utils_1 = require("../../../utils/Utils");
+const SchemaVerifier_1 = require("../../../utils/paramcoders/SchemaVerifier");
+const PluginManager_1 = require("../../../plugins/PluginManager");
+const FromBtcAmountAssertions_1 = require("../../assertions/FromBtcAmountAssertions");
+const LightningAssertions_1 = require("../../assertions/LightningAssertions");
 /**
  * Swap handler handling from BTCLN swaps using submarine swaps
  */
-class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandler {
+class FromBtcLnTrusted extends SwapHandler_1.SwapHandler {
     constructor(storageDirectory, path, chains, lightning, swapPricing, config) {
-        super(storageDirectory, path, chains, lightning, swapPricing);
+        super(storageDirectory, path, chains, swapPricing);
         this.type = SwapHandler_1.SwapHandlerType.FROM_BTCLN_TRUSTED;
-        this.swapType = null;
         this.activeSubscriptions = new Map();
         this.processedTxIds = new Map();
+        this.lightning = lightning;
+        this.LightningAssertions = new LightningAssertions_1.LightningAssertions(this.logger, lightning);
+        this.AmountAssertions = new FromBtcAmountAssertions_1.FromBtcAmountAssertions(config, swapPricing);
         this.config = config;
         this.config.invoiceTimeoutSeconds = this.config.invoiceTimeoutSeconds || 90;
     }
@@ -145,7 +148,7 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
      * @param invoice
      */
     async htlcReceived(invoiceData, invoice) {
-        const { swapContract, signer } = this.getChain(invoiceData.chainIdentifier);
+        const { signer, chainInterface } = this.getChain(invoiceData.chainIdentifier);
         //Important to prevent race condition and issuing 2 signed init messages at the same time
         if (invoiceData.state === FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.CREATED) {
             if (invoiceData.metadata != null)
@@ -154,7 +157,7 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
             await this.storageManager.saveData(invoice.id, null, invoiceData);
         }
         if (invoiceData.state === FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.RECEIVED) {
-            const balance = swapContract.getBalance(signer.getAddress(), invoiceData.token, false);
+            const balance = chainInterface.getBalance(signer.getAddress(), invoiceData.token);
             try {
                 await this.checkBalance(invoiceData.output, balance, null);
                 if (invoiceData.metadata != null)
@@ -166,11 +169,11 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
             }
             if (invoiceData.state !== FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.RECEIVED)
                 return;
-            const txns = await swapContract.txsTransfer(signer.getAddress(), invoiceData.token, invoiceData.output, invoiceData.dstAddress);
+            const txns = await chainInterface.txsTransfer(signer.getAddress(), invoiceData.token, invoiceData.output, invoiceData.dstAddress);
             let unlock = invoiceData.lock(Infinity);
             if (unlock == null)
                 return;
-            const result = await swapContract.sendAndConfirm(signer, txns, true, null, false, async (txId, rawTx) => {
+            const result = await chainInterface.sendAndConfirm(signer, txns, true, null, false, async (txId, rawTx) => {
                 invoiceData.txIds = { init: txId };
                 invoiceData.scRawTx = rawTx;
                 if (invoiceData.state === FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.RECEIVED) {
@@ -202,7 +205,7 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
         if (invoiceData.state === FromBtcLnTrustedSwap_1.FromBtcLnTrustedSwapState.SENT) {
             if (invoiceData.isLocked())
                 return;
-            const txStatus = await swapContract.getTxStatus(invoiceData.scRawTx);
+            const txStatus = await chainInterface.getTxStatus(invoiceData.scRawTx);
             if (txStatus === "not_found") {
                 //Retry
                 invoiceData.txIds = { init: null };
@@ -269,8 +272,8 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
             chainIdentifier = this.chains.default;
             address = invoice.description;
         }
-        const { swapContract } = this.getChain(chainIdentifier);
-        if (!swapContract.isValidAddress(address))
+        const { chainInterface } = this.getChain(chainIdentifier);
+        if (!chainInterface.isValidAddress(address))
             throw {
                 _httpStatus: 200,
                 code: 10001,
@@ -309,17 +312,17 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
             var _a;
             const metadata = { request: {}, times: {} };
             const chainIdentifier = req.query.chain ?? this.chains.default;
-            const { swapContract, signer } = this.getChain(chainIdentifier);
+            const { signer, chainInterface } = this.getChain(chainIdentifier);
             metadata.times.requestReceived = Date.now();
             /**
              * address: string              solana address of the recipient
              * amount: string               amount (in lamports/smart chain base units) of the invoice
              */
-            (_a = req.query).token ?? (_a.token = swapContract.getNativeCurrencyAddress());
+            (_a = req.query).token ?? (_a.token = chainInterface.getNativeCurrencyAddress());
             const parsedBody = (0, SchemaVerifier_1.verifySchema)(req.query, {
                 address: (val) => val != null &&
                     typeof (val) === "string" &&
-                    swapContract.isValidAddress(val) ? val : null,
+                    chainInterface.isValidAddress(val) ? val : null,
                 token: (val) => val != null &&
                     typeof (val) === "string" &&
                     this.isTokenSupported(chainIdentifier, val) ? val : null,
@@ -333,7 +336,7 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
                     msg: "Invalid request body"
                 };
             metadata.request = parsedBody;
-            const requestedAmount = { input: parsedBody.exactIn, amount: parsedBody.amount };
+            const requestedAmount = { input: parsedBody.exactIn, amount: parsedBody.amount, token: parsedBody.token };
             const request = {
                 chainIdentifier,
                 raw: req,
@@ -342,25 +345,29 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
             };
             const useToken = parsedBody.token;
             //Check request params
-            const fees = await this.preCheckAmounts(request, requestedAmount, useToken);
+            const fees = await this.AmountAssertions.preCheckFromBtcAmounts(this.type, request, requestedAmount);
             metadata.times.requestChecked = Date.now();
             //Create abortController for parallel prefetches
             const responseStream = res.responseStream;
-            const abortController = this.getAbortController(responseStream);
+            const abortController = (0, Utils_1.getAbortController)(responseStream);
             //Pre-fetch data
-            const { pricePrefetchPromise } = this.getFromBtcPricePrefetches(chainIdentifier, useToken, useToken, abortController);
-            const balancePrefetch = swapContract.getBalance(signer.getAddress(), useToken, false).catch(e => {
+            const pricePrefetchPromise = this.swapPricing.preFetchPrice(useToken, chainIdentifier).catch(e => {
+                this.logger.error("pricePrefetchPromise(): pricePrefetch error: ", e);
+                abortController.abort(e);
+                return null;
+            });
+            const balancePrefetch = chainInterface.getBalance(signer.getAddress(), useToken).catch(e => {
                 this.logger.error("getBalancePrefetch(): balancePrefetch error: ", e);
                 abortController.abort(e);
                 return null;
             });
-            const channelsPrefetch = this.getChannelsPrefetch(abortController);
+            const channelsPrefetch = this.LightningAssertions.getChannelsPrefetch(abortController);
             //Check valid amount specified (min/max)
-            const { amountBD, swapFee, swapFeeInToken, totalInToken } = await this.checkFromBtcAmount(request, requestedAmount, fees, useToken, abortController.signal, pricePrefetchPromise);
+            const { amountBD, swapFee, swapFeeInToken, totalInToken } = await this.AmountAssertions.checkFromBtcAmount(this.type, request, { ...requestedAmount, pricePrefetch: pricePrefetchPromise }, fees, abortController.signal);
             metadata.times.priceCalculated = Date.now();
             //Check if we have enough funds to honor the request
             await this.checkBalance(totalInToken, balancePrefetch, abortController.signal);
-            await this.checkInboundLiquidity(amountBD, channelsPrefetch, abortController.signal);
+            await this.LightningAssertions.checkInboundLiquidity(amountBD, channelsPrefetch, abortController.signal);
             metadata.times.balanceChecked = Date.now();
             const secret = (0, crypto_1.randomBytes)(32);
             const hash = (0, crypto_1.createHash)("sha256").update(secret).digest();
@@ -482,14 +489,5 @@ class FromBtcLnTrusted extends FromBtcLnBaseSwapHandler_1.FromBtcLnBaseSwapHandl
             minCltv: Number(this.config.minCltv)
         };
     }
-    processClaimEvent(chainIdentifier, swap, event) {
-        return Promise.resolve();
-    }
-    processInitializeEvent(chainIdentifier, swap, event) {
-        return Promise.resolve();
-    }
-    processRefundEvent(chainIdentifier, swap, event) {
-        return Promise.resolve();
-    }
 }
 exports.FromBtcLnTrusted = FromBtcLnTrusted;

package/dist/swaps/{frombtcln_trusted → trusted/frombtcln_trusted}/FromBtcLnTrustedSwap.d.ts

@@ -1,5 +1,4 @@
-import { SwapData } from "@atomiqlabs/base";
-import { FromBtcBaseSwap } from "../FromBtcBaseSwap";
+import { SwapHandlerSwap } from "../../SwapHandlerSwap";
 export declare enum FromBtcLnTrustedSwapState {
     REFUNDED = -2,
     CANCELED = -1,
@@ -9,8 +8,9 @@ export declare enum FromBtcLnTrustedSwapState {
     CONFIRMED = 3,
     SETTLED = 4
 }
-export declare class FromBtcLnTrustedSwap<T extends SwapData = SwapData> extends FromBtcBaseSwap<T, FromBtcLnTrustedSwapState> {
+export declare class FromBtcLnTrustedSwap extends SwapHandlerSwap<FromBtcLnTrustedSwapState> {
     readonly pr: string;
+    amount: bigint;
     readonly output: bigint;
     readonly dstAddress: string;
     readonly secret: string;
@@ -20,10 +20,15 @@ export declare class FromBtcLnTrustedSwap<T extends SwapData = SwapData> extends
     constructor(obj: any);
     getToken(): string;
     getOutputAmount(): bigint;
-    getClaimHash(): string;
+    getSwapFee(): {
+        inInputToken: bigint;
+        inOutputToken: bigint;
+    };
+    getTotalInputAmount(): bigint;
     getSequence(): bigint;
     serialize(): any;
     isFailed(): boolean;
     isInitiated(): boolean;
     isSuccess(): boolean;
+    getIdentifierHash(): string;
 }

package/dist/swaps/{frombtcln_trusted → trusted/frombtcln_trusted}/FromBtcLnTrustedSwap.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FromBtcLnTrustedSwap = exports.FromBtcLnTrustedSwapState = void 0;
 const crypto_1 = require("crypto");
-const FromBtcBaseSwap_1 = require("../FromBtcBaseSwap");
-const Utils_1 = require("../../utils/Utils");
+const Utils_1 = require("../../../utils/Utils");
+const SwapHandlerSwap_1 = require("../../SwapHandlerSwap");
+const SwapHandler_1 = require("../../SwapHandler");
 var FromBtcLnTrustedSwapState;
 (function (FromBtcLnTrustedSwapState) {
     FromBtcLnTrustedSwapState[FromBtcLnTrustedSwapState["REFUNDED"] = -2] = "REFUNDED";
@@ -14,12 +15,13 @@ var FromBtcLnTrustedSwapState;
     FromBtcLnTrustedSwapState[FromBtcLnTrustedSwapState["CONFIRMED"] = 3] = "CONFIRMED";
     FromBtcLnTrustedSwapState[FromBtcLnTrustedSwapState["SETTLED"] = 4] = "SETTLED";
 })(FromBtcLnTrustedSwapState = exports.FromBtcLnTrustedSwapState || (exports.FromBtcLnTrustedSwapState = {}));
-class FromBtcLnTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
+class FromBtcLnTrustedSwap extends SwapHandlerSwap_1.SwapHandlerSwap {
     constructor(chainIdOrObj, pr, inputMtokens, swapFee, swapFeeInToken, output, secret, dstAddress, token) {
         if (typeof (chainIdOrObj) === "string") {
-            super(chainIdOrObj, (inputMtokens + 999n) / 1000n, swapFee, swapFeeInToken);
+            super(chainIdOrObj, swapFee, swapFeeInToken);
             this.state = FromBtcLnTrustedSwapState.CREATED;
             this.pr = pr;
+            this.amount = (inputMtokens + 999n) / 1000n;
             this.output = output;
             this.secret = secret;
             this.dstAddress = dstAddress;
@@ -28,13 +30,14 @@ class FromBtcLnTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
         else {
             super(chainIdOrObj);
             this.pr = chainIdOrObj.pr;
+            this.amount = (0, Utils_1.deserializeBN)(chainIdOrObj.amount);
             this.output = (0, Utils_1.deserializeBN)(chainIdOrObj.output);
             this.secret = chainIdOrObj.secret;
             this.dstAddress = chainIdOrObj.dstAddress;
             this.token = chainIdOrObj.token;
             this.scRawTx = chainIdOrObj.scRawTx;
         }
-        this.type = null;
+        this.type = SwapHandler_1.SwapHandlerType.FROM_BTCLN_TRUSTED;
     }
     getToken() {
         return this.token;
@@ -42,8 +45,11 @@ class FromBtcLnTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     getOutputAmount() {
         return this.output;
     }
-    getClaimHash() {
-        return (0, crypto_1.createHash)("sha256").update(Buffer.from(this.secret, "hex")).digest().toString("hex");
+    getSwapFee() {
+        return { inInputToken: this.swapFee, inOutputToken: this.swapFeeInToken };
+    }
+    getTotalInputAmount() {
+        return this.amount;
     }
     getSequence() {
         return 0n;
@@ -51,6 +57,7 @@ class FromBtcLnTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     serialize() {
         const partialSerialized = super.serialize();
         partialSerialized.pr = this.pr;
+        partialSerialized.amount = (0, Utils_1.serializeBN)(this.amount);
         partialSerialized.output = (0, Utils_1.serializeBN)(this.output);
         partialSerialized.secret = this.secret;
         partialSerialized.dstAddress = this.dstAddress;
@@ -67,5 +74,8 @@ class FromBtcLnTrustedSwap extends FromBtcBaseSwap_1.FromBtcBaseSwap {
     isSuccess() {
         return this.state === FromBtcLnTrustedSwapState.SETTLED;
     }
+    getIdentifierHash() {
+        return (0, crypto_1.createHash)("sha256").update(Buffer.from(this.secret, "hex")).digest().toString("hex");
+    }
 }
 exports.FromBtcLnTrustedSwap = FromBtcLnTrustedSwap;

package/dist/utils/Utils.d.ts

@@ -10,12 +10,20 @@ export declare function isDefinedRuntimeError(obj: any): obj is DefinedRuntimeEr
 export declare function expressHandlerWrapper(func: (req: Request, res: Response) => Promise<void>): ((req: Request, res: Response & {
     responseStream: ServerParamEncoder;
 }) => void);
-export declare function getLogger(prefix: string): {
-    debug: (msg: any, ...args: any[]) => void;
-    info: (msg: any, ...args: any[]) => void;
-    warn: (msg: any, ...args: any[]) => void;
-    error: (msg: any, ...args: any[]) => void;
+export type LoggerType = {
+    debug: (msg: string, ...args: any[]) => void;
+    info: (msg: string, ...args: any[]) => void;
+    warn: (msg: string, ...args: any[]) => void;
+    error: (msg: string, ...args: any[]) => void;
 };
+export declare function getLogger(prefix: string): LoggerType;
 export declare const HEX_REGEX: RegExp;
 export declare function serializeBN(bn: bigint | null): string | null;
 export declare function deserializeBN(str: string | null): bigint | null;
+export declare function bigIntSorter(a: bigint, b: bigint): -1 | 0 | 1;
+/**
+ * Creates an abort controller that extends the responseStream's abort signal
+ *
+ * @param responseStream
+ */
+export declare function getAbortController(responseStream: ServerParamEncoder): AbortController;

package/dist/utils/Utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeBN = exports.serializeBN = exports.HEX_REGEX = exports.getLogger = exports.expressHandlerWrapper = exports.isDefinedRuntimeError = void 0;
+exports.getAbortController = exports.bigIntSorter = exports.deserializeBN = exports.serializeBN = exports.HEX_REGEX = exports.getLogger = exports.expressHandlerWrapper = exports.isDefinedRuntimeError = void 0;
 function isDefinedRuntimeError(obj) {
     if (obj.code != null && typeof (obj.code) === "number") {
         if (obj.msg != null && typeof (obj.msg) !== "string")
@@ -64,3 +64,25 @@ function deserializeBN(str) {
     return str == null ? null : BigInt(str);
 }
 exports.deserializeBN = deserializeBN;
+function bigIntSorter(a, b) {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+exports.bigIntSorter = bigIntSorter;
+/**
+ * Creates an abort controller that extends the responseStream's abort signal
+ *
+ * @param responseStream
+ */
+function getAbortController(responseStream) {
+    const abortController = new AbortController();
+    if (responseStream == null || responseStream.getAbortSignal == null)
+        return abortController;
+    const responseStreamAbortController = responseStream.getAbortSignal();
+    responseStreamAbortController.addEventListener("abort", () => abortController.abort(responseStreamAbortController.reason));
+    return abortController;
+}
+exports.getAbortController = getAbortController;

package/dist/wallets/IBitcoinWallet.d.ts

@@ -47,15 +47,21 @@ export interface IBitcoinWallet {
     getWalletTransactions(startHeight?: number): Promise<BtcTx[]>;
     getWalletTransaction(txId: string): Promise<BtcTx | null>;
     subscribeToWalletTransactions(callback: (tx: BtcTx) => void, abortSignal?: AbortSignal): void;
+    fundPsbt(psbt: Transaction, feeRate?: number): Promise<Transaction>;
     signPsbt(psbt: Transaction): Promise<SignPsbtResponse>;
     sendRawTransaction(tx: string): Promise<void>;
     getSignedTransaction(destination: string, amount: number, feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
+    getSignedMultiTransaction(destinations: {
+        address: string;
+        amount: number;
+    }[], feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
     estimateFee(destination: string, amount: number, feeRate?: number, feeRateMultiplier?: number): Promise<{
         satsPerVbyte: number;
         networkFee: number;
     }>;
     drainAll(destination: string | Buffer, inputs: Omit<BitcoinUtxo, "address">[], feeRate?: number): Promise<SignPsbtResponse>;
     burnAll(inputs: Omit<BitcoinUtxo, "address">[]): Promise<SignPsbtResponse>;
+    parsePsbt(psbt: Transaction): Promise<BtcTx>;
     getBlockheight(): Promise<number>;
     getFeeRate(): Promise<number>;
 }

package/dist/wallets/ISpvVaultSigner.d.ts

@@ -0,0 +1,7 @@
+import { Transaction } from "@scure/btc-signer";
+export interface ISpvVaultSigner {
+    init(): Promise<void>;
+    getAddressType(): "p2wpkh" | "p2tr";
+    getAddress(chainId: string, vaultId: bigint): Promise<string>;
+    signPsbt(chainId: string, vaultId: bigint, psbt: Transaction, inputs: number[]): Promise<Transaction>;
+}

package/dist/wallets/ISpvVaultSigner.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/wallets/ISpvVaultWallet.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import { Command } from "@atomiqlabs/server-base";
+import { Transaction } from "@scure/btc-signer";
+export type BitcoinUtxo = {
+    address: string;
+    type: "p2wpkh" | "p2sh-p2wpkh" | "p2tr";
+    confirmations: number;
+    outputScript: Buffer;
+    value: number;
+    txId: string;
+    vout: number;
+};
+export type SignPsbtResponse = {
+    psbt: Transaction;
+    tx: Transaction;
+    raw: string;
+    txId: string;
+    networkFee: number;
+};
+export interface ISpvVaultSigner {
+    init(): Promise<void>;
+    isReady(): boolean;
+    getStatus(): string;
+    getStatusInfo(): Promise<Record<string, string>>;
+    getCommands(): Command<any>[];
+    getAddressType(): "p2wpkh" | "p2sh-p2wpkh" | "p2tr";
+    /**
+     * Returns an unused address suitable for receiving
+     */
+    getAddress(vaultId: bigint): Promise<string>;
+    signPsbt(vaultId: bigint, psbt: Transaction): Promise<SignPsbtResponse>;
+    sendRawTransaction(tx: string): Promise<void>;
+    getSignedTransaction(destination: string, amount: number, feeRate?: number, nonce?: bigint, maxAllowedFeeRate?: number): Promise<SignPsbtResponse>;
+    estimateFee(destination: string, amount: number, feeRate?: number, feeRateMultiplier?: number): Promise<{
+        satsPerVbyte: number;
+        networkFee: number;
+    }>;
+    drainAll(destination: string | Buffer, inputs: Omit<BitcoinUtxo, "address">[], feeRate?: number): Promise<SignPsbtResponse>;
+    burnAll(inputs: Omit<BitcoinUtxo, "address">[]): Promise<SignPsbtResponse>;
+    getBlockheight(): Promise<number>;
+    getFeeRate(): Promise<number>;
+}

package/dist/wallets/ISpvVaultWallet.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/lp-lib",
-  "version": "12.1.0",
+  "version": "13.0.0-beta.1",
   "description": "Main functionality implementation for atomiq LP node",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -22,7 +22,7 @@
   "author": "adambor",
   "license": "ISC",
   "dependencies": {
-    "@atomiqlabs/base": "^8.0.0",
+    "@atomiqlabs/base": "^9.0.0-beta.1",
     "@atomiqlabs/server-base": "2.0.0",
     "@scure/btc-signer": "1.6.0",
     "express": "4.21.1",

package/src/index.ts

@@ -9,21 +9,21 @@ export * from "./storage/IIntermediaryStorage";
 export * from "./storagemanager/StorageManager";
 export * from "./storagemanager/IntermediaryStorageManager";
 
-export * from "./swaps/frombtc_abstract/FromBtcAbs";
-export * from "./swaps/frombtc_abstract/FromBtcSwapAbs";
-export * from "./swaps/frombtcln_abstract/FromBtcLnAbs";
-export * from "./swaps/frombtcln_abstract/FromBtcLnSwapAbs";
-export * from "./swaps/tobtc_abstract/ToBtcAbs";
-export * from "./swaps/tobtc_abstract/ToBtcSwapAbs";
-export * from "./swaps/tobtcln_abstract/ToBtcLnAbs";
-export * from "./swaps/tobtcln_abstract/ToBtcLnSwapAbs";
-
-export * from "./swaps/frombtc_trusted/FromBtcTrusted";
-export * from "./swaps/frombtc_trusted/FromBtcTrustedSwap";
-export * from "./swaps/frombtcln_trusted/FromBtcLnTrusted";
-export * from "./swaps/frombtcln_trusted/FromBtcLnTrustedSwap";
-
-export * from "./swaps/ISwapPrice";
+export * from "./swaps/escrow/frombtc_abstract/FromBtcAbs";
+export * from "./swaps/escrow/frombtc_abstract/FromBtcSwapAbs";
+export * from "./swaps/escrow/frombtcln_abstract/FromBtcLnAbs";
+export * from "./swaps/escrow/frombtcln_abstract/FromBtcLnSwapAbs";
+export * from "./swaps/escrow/tobtc_abstract/ToBtcAbs";
+export * from "./swaps/escrow/tobtc_abstract/ToBtcSwapAbs";
+export * from "./swaps/escrow/tobtcln_abstract/ToBtcLnAbs";
+export * from "./swaps/escrow/tobtcln_abstract/ToBtcLnSwapAbs";
+
+export * from "./swaps/trusted/frombtc_trusted/FromBtcTrusted";
+export * from "./swaps/trusted/frombtc_trusted/FromBtcTrustedSwap";
+export * from "./swaps/trusted/frombtcln_trusted/FromBtcLnTrusted";
+export * from "./swaps/trusted/frombtcln_trusted/FromBtcLnTrustedSwap";
+
+export * from "./prices/ISwapPrice";
 export * from "./swaps/SwapHandler";
 export * from "./swaps/SwapHandlerSwap";
 
@@ -43,3 +43,9 @@ export * from "./utils/paramcoders/server/ServerParamEncoder";
 
 export * from "./wallets/IBitcoinWallet";
 export * from "./wallets/ILightningWallet";
+export * from "./wallets/ISpvVaultSigner";
+
+export * from "./swaps/spv_vault_swap/SpvVaults";
+export * from "./swaps/spv_vault_swap/SpvVault";
+export * from "./swaps/spv_vault_swap/SpvVaultSwap";
+export * from "./swaps/spv_vault_swap/SpvVaultSwapHandler";