@atomiqlabs/sdk 8.8.3 → 8.9.1

package/dist/swaps/ISwap.js

@@ -99,6 +99,7 @@ class ISwap {
             this.createdAt = swapInitOrObj.createdAt ?? swapInitOrObj.expiry;
             this._randomNonce = swapInitOrObj.randomNonce;
             this._contractVersion = swapInitOrObj.contractVersion;
+            this._meta = swapInitOrObj._meta;
         }
         if (this.version !== this.currentVersion) {
             this.upgradeVersion();
@@ -159,6 +160,18 @@ class ISwap {
             }
         }
     }
+    /**
+     * Returns the specific state along with the human-readable description of that state
+     *
+     * @internal
+     */
+    _getStateInfo(state) {
+        return {
+            state: state,
+            name: this.swapStateName(state),
+            description: this.swapStateDescription[state]
+        };
+    }
     /**
      * Re-fetches & revalidates the price data based on the current market prices
      */
@@ -225,6 +238,18 @@ class ISwap {
         if ((typeof (signer) === "string" ? signer : signer.getAddress()) !== this._getInitiator())
             throw new Error("Invalid signer provided!");
     }
+    /**
+     * Await and prepares a list of passed transactions
+     *
+     * @param txsPromise
+     * @internal
+     */
+    async prepareTransactions(txsPromise) {
+        const txs = await txsPromise;
+        if (this.wrapper._chain.prepareTxs == null)
+            return txs;
+        return await this.wrapper._chain.prepareTxs(txs);
+    }
     /**
      * Sets this swap as initiated
      * @internal
@@ -269,11 +294,7 @@ class ISwap {
      * Returns the current state of the swap along with the human-readable description of the state
      */
     getStateInfo() {
-        return {
-            state: this._state,
-            name: this.swapStateName(this._state),
-            description: this.swapStateDescription[this._state]
-        };
+        return this._getStateInfo(this._state);
     }
     //////////////////////////////
     //// Storage
@@ -331,7 +352,8 @@ class ISwap {
             exactIn: this.exactIn,
             createdAt: this.createdAt,
             randomNonce: this._randomNonce,
-            contractVersion: this._contractVersion
+            contractVersion: this._contractVersion,
+            _meta: this._meta
         };
     }
     //////////////////////////////

package/dist/swaps/ISwapWrapper.d.ts

@@ -9,6 +9,7 @@ import { SwapType } from "../enums/SwapType";
 import { UnifiedSwapStorage } from "../storage/UnifiedSwapStorage";
 import { SCToken } from "../types/Token";
 import { PriceInfoType } from "../types/PriceInfoType";
+import { IntermediaryAPI } from "../intermediaries/apis/IntermediaryAPI";
 export declare const DEFAULT_MAX_PARALLEL_SWAP_TICKS = 50;
 export declare const DEFAULT_MAX_PARALLEL_SWAP_SYNCS = 50;
 /**
@@ -132,6 +133,11 @@ export declare abstract class ISwapWrapper<T extends ChainType, D extends SwapTy
     readonly _tokens: {
         [tokenAddress: string]: SCToken<T["ChainId"]>;
     };
+    /**
+     * LP API Used to communicate with the LPs
+     * @internal
+     */
+    readonly _lpApi: IntermediaryAPI;
     /**
      * Chain identifier string of this wrapper
      */
@@ -142,7 +148,7 @@ export declare abstract class ISwapWrapper<T extends ChainType, D extends SwapTy
     readonly events: EventEmitter<{
         swapState: [D["Swap"]];
     }>;
-    constructor(chainIdentifier: T["ChainId"], unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], prices: ISwapPrice, tokens: WrapperCtorTokens, options: O, events?: EventEmitter<{
+    constructor(chainIdentifier: T["ChainId"], unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], prices: ISwapPrice, tokens: WrapperCtorTokens, lpApi: IntermediaryAPI, options: O, events?: EventEmitter<{
         swapState: [ISwap];
     }>);
     /**
@@ -282,4 +288,8 @@ export declare abstract class ISwapWrapper<T extends ChainType, D extends SwapTy
      * @internal
      */
     _getPendingSwap(id: string): D["Swap"] | null;
+    /**
+     * @internal
+     */
+    _getSignerAddress(signer?: string | T["Signer"] | T["NativeSigner"]): Promise<string | undefined>;
 }

package/dist/swaps/ISwapWrapper.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ISwapWrapper = exports.DEFAULT_MAX_PARALLEL_SWAP_SYNCS = exports.DEFAULT_MAX_PARALLEL_SWAP_TICKS = void 0;
+const base_1 = require("@atomiqlabs/base");
 const events_1 = require("events");
 const IntermediaryError_1 = require("../errors/IntermediaryError");
 const Logger_1 = require("../utils/Logger");
@@ -14,7 +15,7 @@ exports.DEFAULT_MAX_PARALLEL_SWAP_SYNCS = 50;
  * @category Swaps/Base
  */
 class ISwapWrapper {
-    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, events) {
+    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, lpApi, options, events) {
         /**
          * Logger instance
          * @internal
@@ -41,6 +42,7 @@ class ISwapWrapper {
         this._chain = chain;
         this._prices = prices;
         this.events = events || new events_1.EventEmitter();
+        this._lpApi = lpApi;
         this._options = options;
         this._tokens = tokens;
     }
@@ -247,8 +249,8 @@ class ISwapWrapper {
         for (let i = 0; i < pastSwaps.length; i += maxParallelSyncs) {
             const { removeSwaps, changedSwaps } = await this._checkPastSwaps(pastSwaps.slice(i, i + maxParallelSyncs));
             if (!noSave) {
-                await this.unifiedStorage.removeAll(removeSwaps);
-                await this.unifiedStorage.saveAll(changedSwaps);
+                await this.unifiedStorage.removeAll(removeSwaps, true);
+                await this.unifiedStorage.saveAll(changedSwaps, true);
                 changedSwaps.forEach(swap => swap._emitEvent());
                 removeSwaps.forEach(swap => swap._emitEvent());
             }
@@ -349,5 +351,23 @@ class ISwapWrapper {
     _getPendingSwap(id) {
         return this.pendingSwaps.get(id)?.deref() ?? null;
     }
+    /**
+     * @internal
+     */
+    async _getSignerAddress(signer) {
+        let address = undefined;
+        if (signer != null) {
+            if (typeof (signer) === "string") {
+                address = signer;
+            }
+            else if ((0, base_1.isAbstractSigner)(signer)) {
+                address = signer.getAddress();
+            }
+            else {
+                address = (await this._chain.wrapSigner(signer)).getAddress();
+            }
+        }
+        return address;
+    }
 }
 exports.ISwapWrapper = ISwapWrapper;

package/dist/swaps/escrow_swaps/IEscrowSwap.d.ts

@@ -93,7 +93,7 @@ export declare abstract class IEscrowSwap<T extends ChainType = ChainType, D ext
      * @param abortSignal
      * @internal
      */
-    protected watchdogWaitTillCommited(intervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
+    protected watchdogWaitTillCommited(intervalSeconds?: number, abortSignal?: AbortSignal): Promise<SwapCommitState | null>;
     /**
      * Periodically checks the chain to see whether the swap was finished (claimed or refunded)
      *

package/dist/swaps/escrow_swaps/IEscrowSwap.js

@@ -118,7 +118,7 @@ class IEscrowSwap extends ISwap_1.ISwap {
                 status = await this._contract.getCommitStatus(this._getInitiator(), this._data);
                 if (status?.type === base_1.SwapCommitStateType.NOT_COMMITED &&
                     await this._verifyQuoteDefinitelyExpired())
-                    return false;
+                    return null;
             }
             catch (e) {
                 this.logger.error("watchdogWaitTillCommited(): Error when fetching commit status or signature expiry: ", e);
@@ -126,7 +126,9 @@ class IEscrowSwap extends ISwap_1.ISwap {
         }
         if (abortSignal != null)
             abortSignal.throwIfAborted();
-        return status?.type !== base_1.SwapCommitStateType.EXPIRED;
+        return status?.type === base_1.SwapCommitStateType.EXPIRED
+            ? null
+            : status;
     }
     /**
      * Periodically checks the chain to see whether the swap was finished (claimed or refunded)

package/dist/swaps/escrow_swaps/IEscrowSwapWrapper.d.ts

@@ -9,6 +9,7 @@ import { EventEmitter } from "events";
 import { SwapType } from "../../enums/SwapType";
 import { IEscrowSwap } from "./IEscrowSwap";
 import { Intermediary } from "../../intermediaries/Intermediary";
+import { IntermediaryAPI } from "../../intermediaries/apis/IntermediaryAPI";
 export type IEscrowSwapDefinition<T extends ChainType, W extends IEscrowSwapWrapper<T, any>, S extends IEscrowSwap<T>> = SwapTypeDefinition<T, W, S>;
 /**
  * Base class for wrappers of escrow-based swaps (i.e. swaps utilizing PrTLC and HTLC primitives)
@@ -31,7 +32,7 @@ export declare abstract class IEscrowSwapWrapper<T extends ChainType, D extends
             swapDataConstructor: new (data: any) => T["Data"];
         };
     };
-    constructor(chainIdentifier: string, unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], prices: ISwapPrice, tokens: WrapperCtorTokens, options: O, versionedContracts: {
+    constructor(chainIdentifier: string, unifiedStorage: UnifiedSwapStorage<T>, unifiedChainEvents: UnifiedSwapEventListener<T>, chain: T["ChainInterface"], prices: ISwapPrice, tokens: WrapperCtorTokens, lpApi: IntermediaryAPI, options: O, versionedContracts: {
         [version: string]: {
             swapContract: T["Contract"];
             swapDataConstructor: new (data: any) => T["Data"];

package/dist/swaps/escrow_swaps/IEscrowSwapWrapper.js

@@ -9,8 +9,8 @@ const base_1 = require("@atomiqlabs/base");
  * @category Swaps/Abstract
  */
 class IEscrowSwapWrapper extends ISwapWrapper_1.ISwapWrapper {
-    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, versionedContracts, events) {
-        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, events);
+    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, lpApi, options, versionedContracts, events) {
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, lpApi, options, events);
         /**
          * @internal
          */

package/dist/swaps/escrow_swaps/frombtc/IFromBTCLNWrapper.d.ts

@@ -13,6 +13,7 @@ import { Intermediary } from "../../../intermediaries/Intermediary";
 import { PaymentRequestObject, TagsObject } from "@atomiqlabs/bolt11";
 import { IEscrowSwap } from "../IEscrowSwap";
 import { LNURLWithdrawParamsWithUrl } from "../../../types/lnurl/LNURLWithdraw";
+import { IntermediaryAPI } from "../../../intermediaries/apis/IntermediaryAPI";
 export type IFromBTCLNDefinition<T extends ChainType, W extends IFromBTCLNWrapper<T, any>, S extends IEscrowSwap<T>> = IFromBTCDefinition<T, W, S>;
 /**
  * Base class for wrappers of escrow-based Lightning -> Smart chain swaps
@@ -33,6 +34,7 @@ export declare abstract class IFromBTCLNWrapper<T extends ChainType, D extends I
      * @param tokens
      * @param versionedContracts
      * @param lnApi
+     * @param lpApi
      * @param options
      * @param events Instance to use for emitting events
      */
@@ -41,7 +43,7 @@ export declare abstract class IFromBTCLNWrapper<T extends ChainType, D extends I
             swapContract: T["Contract"];
             swapDataConstructor: new (data: any) => T["Data"];
         };
-    }, lnApi: LightningNetworkApi, options: O, events?: EventEmitter<{
+    }, lnApi: LightningNetworkApi, lpApi: IntermediaryAPI, options: O, events?: EventEmitter<{
         swapState: [IEscrowSwap];
     }>);
     /**

package/dist/swaps/escrow_swaps/frombtc/IFromBTCLNWrapper.js

@@ -23,11 +23,12 @@ class IFromBTCLNWrapper extends IFromBTCWrapper_1.IFromBTCWrapper {
      * @param tokens
      * @param versionedContracts
      * @param lnApi
+     * @param lpApi
      * @param options
      * @param events Instance to use for emitting events
      */
-    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, versionedContracts, lnApi, options, events) {
-        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, versionedContracts, events);
+    constructor(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, versionedContracts, lnApi, lpApi, options, events) {
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, lpApi, options, versionedContracts, events);
         this.lnApi = lnApi;
     }
     /**

package/dist/swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap.d.ts

@@ -13,7 +13,9 @@ import { TokenAmount } from "../../../../types/TokenAmount";
 import { BtcToken, SCToken } from "../../../../types/Token";
 import { LoggerType } from "../../../../utils/Logger";
 import { LNURLWithdraw } from "../../../../types/lnurl/LNURLWithdraw";
-import { SwapExecutionAction } from "../../../../types/SwapExecutionAction";
+import { SwapExecutionActionSendToAddress, SwapExecutionActionSignSmartChainTx } from "../../../../types/SwapExecutionAction";
+import { SwapExecutionStepPayment, SwapExecutionStepSettlement } from "../../../../types/SwapExecutionStep";
+import { SwapStateInfo } from "../../../../types/SwapStateInfo";
 /**
  * State enum for legacy Lightning -> Smart chain swaps
  * @category Swaps/Legacy/Lightning → Smart chain
@@ -287,6 +289,31 @@ export declare class FromBTCLNSwap<T extends ChainType = ChainType> extends IFro
         lightningTxCheckIntervalSeconds?: number;
         delayBetweenCommitAndClaimSeconds?: number;
     }): Promise<boolean>;
+    /**
+     * @internal
+     */
+    protected _getExecutionStatus(options?: {
+        secret?: string;
+    }): Promise<{
+        steps: [SwapExecutionStepPayment<"LIGHTNING">, SwapExecutionStepSettlement<T["ChainId"], "awaiting_manual">];
+        buildCurrentAction: (actionOptions?: {
+            skipChecks?: boolean;
+        }) => Promise<SwapExecutionActionSendToAddress<true> | SwapExecutionActionSignSmartChainTx<T> | undefined>;
+        state: FromBTCLNSwapState;
+    }>;
+    /**
+     * @internal
+     */
+    private _buildLightningPaymentAction;
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    _submitExecutionTransactions(txs: (T["SignedTXType"] | string)[], abortSignal?: AbortSignal, requiredStates?: FromBTCLNSwapState[], idempotent?: boolean): Promise<string[]>;
+    /**
+     * @internal
+     */
+    private _buildClaimSmartChainTxAction;
     /**
      * @inheritDoc
      *
@@ -297,43 +324,32 @@ export declare class FromBTCLNSwap<T extends ChainType = ChainType> extends IFro
      * @param options.secret A swap secret to use for the claim transaction, generally only needed if the swap
      *  was recovered from on-chain data, or the pre-image was generated outside the SDK
      */
-    txsExecute(options?: {
+    getExecutionAction(options?: {
         skipChecks?: boolean;
         secret?: string;
-    }): Promise<{
-        name: "Payment";
-        description: string;
-        chain: "LIGHTNING";
-        txs: {
-            type: "BOLT11_PAYMENT_REQUEST";
-            address: string;
-            hyperlink: string;
-        }[];
-    }[] | ({
-        name: "Commit";
-        description: string;
-        chain: T["ChainId"];
-        txs: T["TX"][];
-    } | {
-        name: "Claim";
-        description: string;
-        chain: T["ChainId"];
-        txs: T["TX"][];
-    })[]>;
+    }): Promise<SwapExecutionActionSendToAddress<true> | SwapExecutionActionSignSmartChainTx<T> | undefined>;
     /**
      * @inheritDoc
-     *
-     * @param options
-     * @param options.skipChecks Skip checks like making sure init signature is still valid and swap
-     *  wasn't commited yet (this is handled on swap creation, if you commit right after quoting, you
-     *  can use `skipChecks=true`)
-     * @param options.secret A swap secret to use for the claim transaction, generally only needed if the swap
-     *  was recovered from on-chain data, or the pre-image was generated outside the SDK
      */
-    getCurrentActions(options?: {
+    getExecutionStatus(options?: {
+        skipBuildingAction?: boolean;
         skipChecks?: boolean;
         secret?: string;
-    }): Promise<SwapExecutionAction<T>[]>;
+    }): Promise<{
+        steps: [
+            SwapExecutionStepPayment<"LIGHTNING">,
+            SwapExecutionStepSettlement<T["ChainId"], "awaiting_manual">
+        ];
+        currentAction: SwapExecutionActionSendToAddress<true> | SwapExecutionActionSignSmartChainTx<T> | undefined;
+        stateInfo: SwapStateInfo<FromBTCLNSwapState>;
+    }>;
+    /**
+     * @inheritDoc
+     */
+    getExecutionSteps(): Promise<[
+        SwapExecutionStepPayment<"LIGHTNING">,
+        SwapExecutionStepSettlement<T["ChainId"], "awaiting_manual">
+    ]>;
     /**
      * Checks whether the LP received the LN payment and we can continue by committing & claiming the HTLC on-chain
      *