@atomiqlabs/lp-lib 15.0.2 → 15.0.4

package/dist/swaps/escrow/ToBtcBaseSwapHandler.d.ts

@@ -1,53 +1,53 @@
-import { MultichainData, SwapBaseConfig } from "../SwapHandler";
-import { SwapData } from "@atomiqlabs/base";
-import { ServerParamEncoder } from "../../utils/paramcoders/server/ServerParamEncoder";
-import { IParamReader } from "../../utils/paramcoders/IParamReader";
-import { Request } from "express";
-import { ToBtcBaseSwap } from "./ToBtcBaseSwap";
-import { EscrowHandler } from "./EscrowHandler";
-import { ToBtcAmountAssertions } from "../assertions/ToBtcAmountAssertions";
-import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
-import { ISwapPrice } from "../../prices/ISwapPrice";
-export type ToBtcBaseConfig = SwapBaseConfig & {
-    gracePeriod: bigint;
-    refundAuthorizationTimeout: number;
-};
-export declare abstract class ToBtcBaseSwapHandler<V extends ToBtcBaseSwap<SwapData, S>, S> extends EscrowHandler<V, S> {
-    readonly AmountAssertions: ToBtcAmountAssertions;
-    readonly pdaExistsForToken: {
-        [chainIdentifier: string]: {
-            [token: string]: boolean;
-        };
-    };
-    constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chainsData: MultichainData, swapPricing: ISwapPrice, config: ToBtcBaseConfig);
-    protected checkVaultInitialized(chainIdentifier: string, token: string): Promise<void>;
-    /**
-     * Starts pre-fetches for swap pricing & signature data
-     *
-     * @param chainIdentifier
-     * @param token
-     * @param responseStream
-     * @param abortController
-     */
-    protected getToBtcPrefetches(chainIdentifier: string, token: string, responseStream: ServerParamEncoder, abortController: AbortController): {
-        pricePrefetchPromise?: Promise<bigint>;
-        signDataPrefetchPromise?: Promise<any>;
-    };
-    /**
-     * Signs the created swap
-     *
-     * @param chainIdentifier
-     * @param swapObject
-     * @param req
-     * @param abortSignal
-     * @param signDataPrefetchPromise
-     */
-    protected getToBtcSignatureData(chainIdentifier: string, swapObject: SwapData, req: Request & {
-        paramReader: IParamReader;
-    }, abortSignal: AbortSignal, signDataPrefetchPromise?: Promise<any>): Promise<{
-        prefix: string;
-        timeout: string;
-        signature: string;
-        feeRate: string;
-    }>;
-}
+import { MultichainData, SwapBaseConfig } from "../SwapHandler";
+import { SwapData } from "@atomiqlabs/base";
+import { ServerParamEncoder } from "../../utils/paramcoders/server/ServerParamEncoder";
+import { IParamReader } from "../../utils/paramcoders/IParamReader";
+import { Request } from "express";
+import { ToBtcBaseSwap } from "./ToBtcBaseSwap";
+import { EscrowHandler } from "./EscrowHandler";
+import { ToBtcAmountAssertions } from "../assertions/ToBtcAmountAssertions";
+import { IIntermediaryStorage } from "../../storage/IIntermediaryStorage";
+import { ISwapPrice } from "../../prices/ISwapPrice";
+export type ToBtcBaseConfig = SwapBaseConfig & {
+    gracePeriod: bigint;
+    refundAuthorizationTimeout: number;
+};
+export declare abstract class ToBtcBaseSwapHandler<V extends ToBtcBaseSwap<SwapData, S>, S> extends EscrowHandler<V, S> {
+    readonly AmountAssertions: ToBtcAmountAssertions;
+    readonly pdaExistsForToken: {
+        [chainIdentifier: string]: {
+            [token: string]: boolean;
+        };
+    };
+    constructor(storageDirectory: IIntermediaryStorage<V>, path: string, chainsData: MultichainData, swapPricing: ISwapPrice, config: ToBtcBaseConfig);
+    protected checkVaultInitialized(chainIdentifier: string, token: string): Promise<void>;
+    /**
+     * Starts pre-fetches for swap pricing & signature data
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param responseStream
+     * @param abortController
+     */
+    protected getToBtcPrefetches(chainIdentifier: string, token: string, responseStream: ServerParamEncoder, abortController: AbortController): {
+        pricePrefetchPromise?: Promise<bigint>;
+        signDataPrefetchPromise?: Promise<any>;
+    };
+    /**
+     * Signs the created swap
+     *
+     * @param chainIdentifier
+     * @param swapObject
+     * @param req
+     * @param abortSignal
+     * @param signDataPrefetchPromise
+     */
+    protected getToBtcSignatureData(chainIdentifier: string, swapObject: SwapData, req: Request & {
+        paramReader: IParamReader;
+    }, abortSignal: AbortSignal, signDataPrefetchPromise?: Promise<any>): Promise<{
+        prefix: string;
+        timeout: string;
+        signature: string;
+        feeRate: string;
+    }>;
+}

package/dist/swaps/escrow/ToBtcBaseSwapHandler.js

@@ -1,81 +1,81 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToBtcBaseSwapHandler = void 0;
-const SchemaVerifier_1 = require("../../utils/paramcoders/SchemaVerifier");
-const EscrowHandler_1 = require("./EscrowHandler");
-const ToBtcAmountAssertions_1 = require("../assertions/ToBtcAmountAssertions");
-class ToBtcBaseSwapHandler extends EscrowHandler_1.EscrowHandler {
-    constructor(storageDirectory, path, chainsData, swapPricing, config) {
-        super(storageDirectory, path, chainsData, swapPricing);
-        this.pdaExistsForToken = {};
-        this.AmountAssertions = new ToBtcAmountAssertions_1.ToBtcAmountAssertions(config, swapPricing);
-    }
-    async checkVaultInitialized(chainIdentifier, token) {
-        if (!this.pdaExistsForToken[chainIdentifier] || !this.pdaExistsForToken[chainIdentifier][token]) {
-            this.logger.debug("checkVaultInitialized(): checking vault exists for chain: " + chainIdentifier + " token: " + token);
-            const { swapContract, signer } = this.getChain(chainIdentifier);
-            const reputation = await swapContract.getIntermediaryReputation(signer.getAddress(), token);
-            this.logger.debug("checkVaultInitialized(): vault state, chain: " + chainIdentifier + " token: " + token + " exists: " + (reputation != null));
-            if (reputation != null) {
-                if (this.pdaExistsForToken[chainIdentifier] == null)
-                    this.pdaExistsForToken[chainIdentifier] = {};
-                this.pdaExistsForToken[chainIdentifier][token] = true;
-            }
-            else {
-                throw {
-                    code: 20201,
-                    msg: "Token not supported!"
-                };
-            }
-        }
-    }
-    /**
-     * Starts pre-fetches for swap pricing & signature data
-     *
-     * @param chainIdentifier
-     * @param token
-     * @param responseStream
-     * @param abortController
-     */
-    getToBtcPrefetches(chainIdentifier, token, responseStream, abortController) {
-        //Fetch pricing & signature data in parallel
-        const pricePrefetchPromise = this.swapPricing.preFetchPrice(token, chainIdentifier).catch(e => {
-            this.logger.error("getToBtcPrefetches(): pricePrefetch error", e);
-            abortController.abort(e);
-            return null;
-        });
-        return {
-            pricePrefetchPromise,
-            signDataPrefetchPromise: this.getSignDataPrefetch(chainIdentifier, abortController, responseStream)
-        };
-    }
-    /**
-     * Signs the created swap
-     *
-     * @param chainIdentifier
-     * @param swapObject
-     * @param req
-     * @param abortSignal
-     * @param signDataPrefetchPromise
-     */
-    async getToBtcSignatureData(chainIdentifier, swapObject, req, abortSignal, signDataPrefetchPromise) {
-        const prefetchedSignData = signDataPrefetchPromise != null ? await signDataPrefetchPromise : null;
-        if (prefetchedSignData != null)
-            this.logger.debug("getToBtcSignatureData(): pre-fetched signature data: ", prefetchedSignData);
-        abortSignal.throwIfAborted();
-        const feeRateObj = await req.paramReader.getParams({
-            feeRate: SchemaVerifier_1.FieldTypeEnum.String
-        }).catch(() => null);
-        abortSignal.throwIfAborted();
-        const feeRate = feeRateObj?.feeRate != null && typeof (feeRateObj.feeRate) === "string" ? feeRateObj.feeRate : null;
-        this.logger.debug("getToBtcSignatureData(): using fee rate from client: ", feeRate);
-        const { swapContract, signer } = this.getChain(chainIdentifier);
-        const sigData = await swapContract.getInitSignature(signer, swapObject, this.getInitAuthorizationTimeout(chainIdentifier), prefetchedSignData, feeRate);
-        abortSignal.throwIfAborted();
-        return {
-            ...sigData,
-            feeRate
-        };
-    }
-}
-exports.ToBtcBaseSwapHandler = ToBtcBaseSwapHandler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToBtcBaseSwapHandler = void 0;
+const SchemaVerifier_1 = require("../../utils/paramcoders/SchemaVerifier");
+const EscrowHandler_1 = require("./EscrowHandler");
+const ToBtcAmountAssertions_1 = require("../assertions/ToBtcAmountAssertions");
+class ToBtcBaseSwapHandler extends EscrowHandler_1.EscrowHandler {
+    constructor(storageDirectory, path, chainsData, swapPricing, config) {
+        super(storageDirectory, path, chainsData, swapPricing);
+        this.pdaExistsForToken = {};
+        this.AmountAssertions = new ToBtcAmountAssertions_1.ToBtcAmountAssertions(config, swapPricing);
+    }
+    async checkVaultInitialized(chainIdentifier, token) {
+        if (!this.pdaExistsForToken[chainIdentifier] || !this.pdaExistsForToken[chainIdentifier][token]) {
+            this.logger.debug("checkVaultInitialized(): checking vault exists for chain: " + chainIdentifier + " token: " + token);
+            const { swapContract, signer } = this.getChain(chainIdentifier);
+            const reputation = await swapContract.getIntermediaryReputation(signer.getAddress(), token);
+            this.logger.debug("checkVaultInitialized(): vault state, chain: " + chainIdentifier + " token: " + token + " exists: " + (reputation != null));
+            if (reputation != null) {
+                if (this.pdaExistsForToken[chainIdentifier] == null)
+                    this.pdaExistsForToken[chainIdentifier] = {};
+                this.pdaExistsForToken[chainIdentifier][token] = true;
+            }
+            else {
+                throw {
+                    code: 20201,
+                    msg: "Token not supported!"
+                };
+            }
+        }
+    }
+    /**
+     * Starts pre-fetches for swap pricing & signature data
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param responseStream
+     * @param abortController
+     */
+    getToBtcPrefetches(chainIdentifier, token, responseStream, abortController) {
+        //Fetch pricing & signature data in parallel
+        const pricePrefetchPromise = this.swapPricing.preFetchPrice(token, chainIdentifier).catch(e => {
+            this.logger.error("getToBtcPrefetches(): pricePrefetch error", e);
+            abortController.abort(e);
+            return null;
+        });
+        return {
+            pricePrefetchPromise,
+            signDataPrefetchPromise: this.getSignDataPrefetch(chainIdentifier, abortController, responseStream)
+        };
+    }
+    /**
+     * Signs the created swap
+     *
+     * @param chainIdentifier
+     * @param swapObject
+     * @param req
+     * @param abortSignal
+     * @param signDataPrefetchPromise
+     */
+    async getToBtcSignatureData(chainIdentifier, swapObject, req, abortSignal, signDataPrefetchPromise) {
+        const prefetchedSignData = signDataPrefetchPromise != null ? await signDataPrefetchPromise : null;
+        if (prefetchedSignData != null)
+            this.logger.debug("getToBtcSignatureData(): pre-fetched signature data: ", prefetchedSignData);
+        abortSignal.throwIfAborted();
+        const feeRateObj = await req.paramReader.getParams({
+            feeRate: SchemaVerifier_1.FieldTypeEnum.String
+        }).catch(() => null);
+        abortSignal.throwIfAborted();
+        const feeRate = feeRateObj?.feeRate != null && typeof (feeRateObj.feeRate) === "string" ? feeRateObj.feeRate : null;
+        this.logger.debug("getToBtcSignatureData(): using fee rate from client: ", feeRate);
+        const { swapContract, signer } = this.getChain(chainIdentifier);
+        const sigData = await swapContract.getInitSignature(signer, swapObject, this.getInitAuthorizationTimeout(chainIdentifier), prefetchedSignData, feeRate);
+        abortSignal.throwIfAborted();
+        return {
+            ...sigData,
+            feeRate
+        };
+    }
+}
+exports.ToBtcBaseSwapHandler = ToBtcBaseSwapHandler;

package/dist/swaps/escrow/frombtc_abstract/FromBtcAbs.d.ts

@@ -1,83 +1,83 @@
-import { Express } from "express";
-import { FromBtcSwapAbs, FromBtcSwapState } from "./FromBtcSwapAbs";
-import { MultichainData, SwapHandlerType } from "../../SwapHandler";
-import { ISwapPrice } from "../../../prices/ISwapPrice";
-import { ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapData } from "@atomiqlabs/base";
-import { IIntermediaryStorage } from "../../../storage/IIntermediaryStorage";
-import { FromBtcBaseConfig, FromBtcBaseSwapHandler } from "../FromBtcBaseSwapHandler";
-import { IBitcoinWallet } from "../../../wallets/IBitcoinWallet";
-export type FromBtcConfig = FromBtcBaseConfig & {
-    confirmations: number;
-    swapCsvDelta: number;
-};
-export type FromBtcRequestType = {
-    address: string;
-    amount: bigint;
-    token: string;
-    sequence: bigint;
-    exactOut?: boolean;
-};
-/**
- * Swap handler handling from BTC swaps using PTLCs (proof-time locked contracts) and btc relay (on-chain bitcoin SPV)
- */
-export declare class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSwapState> {
-    readonly type = SwapHandlerType.FROM_BTC;
-    readonly swapType = ChainSwapType.CHAIN;
-    readonly config: FromBtcConfig & {
-        swapTsCsvDelta: bigint;
-    };
-    readonly bitcoin: IBitcoinWallet;
-    constructor(storageDirectory: IIntermediaryStorage<FromBtcSwapAbs>, path: string, chains: MultichainData, bitcoin: IBitcoinWallet, swapPricing: ISwapPrice, config: FromBtcConfig);
-    /**
-     * Returns the payment hash of the swap, takes swap nonce into account. Payment hash is chain-specific.
-     *
-     * @param chainIdentifier
-     * @param address
-     * @param amount
-     */
-    private getHash;
-    /**
-     * Processes past swap
-     *
-     * @param swap
-     * @protected
-     * @returns true if the swap should be refunded, false if nothing should be done
-     */
-    protected processPastSwap(swap: FromBtcSwapAbs): Promise<boolean>;
-    /**
-     * Checks past swaps, refunds and deletes ones that are already expired.
-     */
-    protected processPastSwaps(): Promise<void>;
-    /**
-     * Refunds all swaps (calls SC on-chain refund function)
-     *
-     * @param refundSwaps
-     * @protected
-     */
-    protected refundSwaps(refundSwaps: FromBtcSwapAbs[]): Promise<void>;
-    protected processInitializeEvent(chainIdentifier: string, savedSwap: FromBtcSwapAbs, event: InitializeEvent<SwapData>): Promise<void>;
-    protected processClaimEvent(chainIdentifier: string, savedSwap: FromBtcSwapAbs, event: ClaimEvent<SwapData>): Promise<void>;
-    protected processRefundEvent(chainIdentifier: string, savedSwap: FromBtcSwapAbs, event: RefundEvent<SwapData>): Promise<void>;
-    /**
-     * Calculates the requested claimer bounty, based on client's request
-     *
-     * @param req
-     * @param expiry
-     * @param signal
-     * @throws {DefinedRuntimeError} will throw an error if the plugin cancelled the request
-     * @returns {Promise<BN>} resulting claimer bounty to be used with the swap
-     */
-    private getClaimerBounty;
-    private getDummySwapData;
-    /**
-     * Sets up required listeners for the REST server
-     *
-     * @param restServer
-     */
-    startRestServer(restServer: Express): void;
-    /**
-     * Initializes swap handler, loads data and subscribes to chain events
-     */
-    init(): Promise<void>;
-    getInfoData(): any;
-}
+import { Express } from "express";
+import { FromBtcSwapAbs, FromBtcSwapState } from "./FromBtcSwapAbs";
+import { MultichainData, SwapHandlerType } from "../../SwapHandler";
+import { ISwapPrice } from "../../../prices/ISwapPrice";
+import { ChainSwapType, ClaimEvent, InitializeEvent, RefundEvent, SwapData } from "@atomiqlabs/base";
+import { IIntermediaryStorage } from "../../../storage/IIntermediaryStorage";
+import { FromBtcBaseConfig, FromBtcBaseSwapHandler } from "../FromBtcBaseSwapHandler";
+import { IBitcoinWallet } from "../../../wallets/IBitcoinWallet";
+export type FromBtcConfig = FromBtcBaseConfig & {
+    confirmations: number;
+    swapCsvDelta: number;
+};
+export type FromBtcRequestType = {
+    address: string;
+    amount: bigint;
+    token: string;
+    sequence: bigint;
+    exactOut?: boolean;
+};
+/**
+ * Swap handler handling from BTC swaps using PTLCs (proof-time locked contracts) and btc relay (on-chain bitcoin SPV)
+ */
+export declare class FromBtcAbs extends FromBtcBaseSwapHandler<FromBtcSwapAbs, FromBtcSwapState> {
+    readonly type = SwapHandlerType.FROM_BTC;
+    readonly swapType = ChainSwapType.CHAIN;
+    readonly config: FromBtcConfig & {
+        swapTsCsvDelta: bigint;
+    };
+    readonly bitcoin: IBitcoinWallet;
+    constructor(storageDirectory: IIntermediaryStorage<FromBtcSwapAbs>, path: string, chains: MultichainData, bitcoin: IBitcoinWallet, swapPricing: ISwapPrice, config: FromBtcConfig);
+    /**
+     * Returns the payment hash of the swap, takes swap nonce into account. Payment hash is chain-specific.
+     *
+     * @param chainIdentifier
+     * @param address
+     * @param amount
+     */
+    private getHash;
+    /**
+     * Processes past swap
+     *
+     * @param swap
+     * @protected
+     * @returns true if the swap should be refunded, false if nothing should be done
+     */
+    protected processPastSwap(swap: FromBtcSwapAbs): Promise<boolean>;
+    /**
+     * Checks past swaps, refunds and deletes ones that are already expired.
+     */
+    protected processPastSwaps(): Promise<void>;
+    /**
+     * Refunds all swaps (calls SC on-chain refund function)
+     *
+     * @param refundSwaps
+     * @protected
+     */
+    protected refundSwaps(refundSwaps: FromBtcSwapAbs[]): Promise<void>;
+    protected processInitializeEvent(chainIdentifier: string, savedSwap: FromBtcSwapAbs, event: InitializeEvent<SwapData>): Promise<void>;
+    protected processClaimEvent(chainIdentifier: string, savedSwap: FromBtcSwapAbs, event: ClaimEvent<SwapData>): Promise<void>;
+    protected processRefundEvent(chainIdentifier: string, savedSwap: FromBtcSwapAbs, event: RefundEvent<SwapData>): Promise<void>;
+    /**
+     * Calculates the requested claimer bounty, based on client's request
+     *
+     * @param req
+     * @param expiry
+     * @param signal
+     * @throws {DefinedRuntimeError} will throw an error if the plugin cancelled the request
+     * @returns {Promise<BN>} resulting claimer bounty to be used with the swap
+     */
+    private getClaimerBounty;
+    private getDummySwapData;
+    /**
+     * Sets up required listeners for the REST server
+     *
+     * @param restServer
+     */
+    startRestServer(restServer: Express): void;
+    /**
+     * Initializes swap handler, loads data and subscribes to chain events
+     */
+    init(): Promise<void>;
+    getInfoData(): any;
+}