@atomiqlabs/sdk 8.8.3 → 8.9.0

package/src/swaps/ISwap.ts

@@ -13,6 +13,7 @@ import {SwapExecutionAction} from "../types/SwapExecutionAction";
 import {LoggerType} from "../utils/Logger";
 import {isPriceInfoType, PriceInfoType} from "../types/PriceInfoType";
 import {SwapStateInfo} from "../types/SwapStateInfo";
+import {SwapExecutionStep} from "../types/SwapExecutionStep";
 
 /**
  * Initialization data for creating a swap
@@ -145,6 +146,12 @@ export abstract class ISwap<
      * @internal
      */
     _contractVersion?: string;
+    /**
+     * Storage specific metadata that can be used for e.g. optimistic concurrency
+     *
+     * @internal
+     */
+    _meta?: any;
 
 
     /**
@@ -218,6 +225,7 @@ export abstract class ISwap<
 
             this._randomNonce = swapInitOrObj.randomNonce;
             this._contractVersion = swapInitOrObj.contractVersion;
+            this._meta = swapInitOrObj._meta;
         }
         if(this.version!==this.currentVersion) {
             this.upgradeVersion();
@@ -259,13 +267,6 @@ export abstract class ISwap<
         });
     }
 
-    /**
-     * Returns a list of steps or transactions required to finish and settle the swap
-     *
-     * @param options Additional options for executing the swap
-     */
-    public abstract txsExecute(options?: any): Promise<SwapExecutionAction<T>[]>;
-
     /**
      * Executes the swap with the provided wallet, the exact arguments for this functions differ for various swap
      *  types. Check the `execute()` function signature in the respective swap class to see the required arguments.
@@ -316,6 +317,19 @@ export abstract class ISwap<
         }
     }
 
+    /**
+     * Returns the specific state along with the human-readable description of that state
+     *
+     * @internal
+     */
+    protected _getStateInfo(state: S): SwapStateInfo<S> {
+        return {
+            state: state,
+            name: this.swapStateName(state),
+            description: this.swapStateDescription[state]
+        };
+    }
+
     /**
      * Re-fetches & revalidates the price data based on the current market prices
      */
@@ -410,6 +424,18 @@ export abstract 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
+     */
+    protected async prepareTransactions(txsPromise: Promise<T["TX"][]>): Promise<T["TX"][]> {
+        const txs = await txsPromise;
+        if(this.wrapper._chain.prepareTxs==null) return txs;
+        return await this.wrapper._chain.prepareTxs(txs);
+    }
+
     /**
      * Returns an escrow hash of the swap
      *
@@ -546,18 +572,62 @@ export abstract class ISwap<
      * Returns the current state of the swap along with the human-readable description of the state
      */
     public getStateInfo(): SwapStateInfo<S> {
-        return {
-            state: this._state,
-            name: this.swapStateName(this._state),
-            description: this.swapStateDescription[this._state]
-        }
+        return this._getStateInfo(this._state);
     }
 
     /**
-     * Returns a state-dependent set of actions for the user to execute, or empty array if there is currently
-     *  no action required from the user to execute.
+     * Returns a current state-dependent action for the user to execute, or `undefined` if there is no more action
+     *  required for this swap - this means that the swap is probably finished (either expired, failed or settled).
+     *
+     * @param options Optional options argument for the additional action context (i.e. passing bitcoin wallet info to
+     *  get funded PSBTs or passing the externally-generated swap secret), see the actual type in the respective swap
+     *  classes
+     */
+    public abstract getExecutionAction(options?: any): Promise<SwapExecutionAction | undefined>;
+
+    /**
+     * Returns a list of execution steps the user has to go through for a given swap, to see the possible execution
+     *  steps check out {@link SwapExecutionStep}.
+     *
+     * @param options Optional options argument for the additional steps context (i.e. automatic settlement timeout),
+     *  see the actual type in the respective swap classes
+     */
+    public abstract getExecutionSteps(options?: any): Promise<SwapExecutionStep[]>;
+
+    /**
+     * Returns the current action and the full execution steps for a given swap. Prefer this to calling
+     *  {@link getExecutionSteps} and {@link getExecutionAction} separately - if called sequentially they might
+     *  return the respective steps/actions in different states if you hit the state transition boundary.
+     *
+     * @param options Optional options argument for the additional execution status context, see the actual type in
+     *  the respective swap classes
      */
-    public abstract getCurrentActions(): Promise<SwapExecutionAction<T>[]>;
+    public abstract getExecutionStatus(options?: { skipBuildingAction?: boolean } & any): Promise<{
+        steps: SwapExecutionStep[],
+        currentAction: SwapExecutionAction | undefined,
+        stateInfo: SwapStateInfo<S>
+    }>;
+
+    /**
+     * Submits signed transactions obtained from the execution action back to the swap.
+     *
+     * @remarks This endpoint will also wait till the submitted transactions are confirmed (on a smart-chain side)
+     *  and till the swap state change is observed from the authoritative chain/intermediary state.
+     *
+     *  If invalid transactions are submitted, i.e. sending a simple noop or transfer transaction instead of the
+     *  expected tx, this call may wait indefinitely unless aborted via the AbortSignal.
+     *
+     * @param txs Signed transactions
+     * @param abortSignal Abort signal
+     * @param requiredStates Optional list of states that the swap has to be in for the transactions to be
+     *  submitted, else throws
+     * @param idempotent Whether the tx submission should be handled idempotently, meaning if any of the supplied
+     *  transactions are already processed as e.g. init, claim, refund or execution transactions the function just
+     *  returns these transaction IDs without actually submitting them
+     *
+     * @internal
+     */
+    abstract _submitExecutionTransactions(txs: (T["SignedTXType"] | string | any)[], abortSignal?: AbortSignal, requiredStates?: S[], idempotent?: boolean): Promise<string[]>;
 
     //////////////////////////////
     //// Amounts & fees
@@ -656,7 +726,9 @@ export abstract class ISwap<
             exactIn: this.exactIn,
             createdAt: this.createdAt,
             randomNonce: this._randomNonce,
-            contractVersion: this._contractVersion
+            contractVersion: this._contractVersion,
+
+            _meta: this._meta
         }
     }
 

package/src/swaps/ISwapWrapper.ts

@@ -1,4 +1,4 @@
-import {ChainEvent, ChainType} from "@atomiqlabs/base";
+import {ChainEvent, ChainType, isAbstractSigner} from "@atomiqlabs/base";
 import {EventEmitter} from "events";
 import {ISwap} from "./ISwap";
 import {ISwapPrice} from "../prices/abstract/ISwapPrice";
@@ -12,6 +12,7 @@ import {getLogger} from "../utils/Logger";
 import {PriceInfoType} from "../types/PriceInfoType";
 import {fromHumanReadableString} from "../utils/TokenUtils";
 import {UserError} from "../errors/UserError";
+import {IntermediaryAPI} from "../intermediaries/apis/IntermediaryAPI";
 
 export const DEFAULT_MAX_PARALLEL_SWAP_TICKS = 50;
 export const DEFAULT_MAX_PARALLEL_SWAP_SYNCS = 50;
@@ -150,6 +151,11 @@ export abstract class ISwapWrapper<
     readonly _tokens: {
         [tokenAddress: string]: SCToken<T["ChainId"]>
     };
+    /**
+     * LP API Used to communicate with the LPs
+     * @internal
+     */
+    readonly _lpApi: IntermediaryAPI;
 
 
     /**
@@ -169,6 +175,7 @@ export abstract class ISwapWrapper<
         chain: T["ChainInterface"],
         prices: ISwapPrice,
         tokens: WrapperCtorTokens,
+        lpApi: IntermediaryAPI,
         options: O,
         events?: EventEmitter<{swapState: [ISwap]}>
     ) {
@@ -184,6 +191,7 @@ export abstract class ISwapWrapper<
         this._chain = chain;
         this._prices = prices;
         this.events = events || new EventEmitter();
+        this._lpApi = lpApi;
         this._options = options;
         this._tokens = tokens;
     }
@@ -426,8 +434,8 @@ export abstract 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());
             }
@@ -537,4 +545,21 @@ export abstract class ISwapWrapper<
         return this.pendingSwaps.get(id)?.deref() ?? null;
     }
 
+    /**
+     * @internal
+     */
+    async _getSignerAddress(signer?: string | T["Signer"] | T["NativeSigner"]): Promise<string | undefined> {
+        let address: string | undefined = undefined;
+        if(signer!=null) {
+            if (typeof (signer) === "string") {
+                address = signer;
+            } else if (isAbstractSigner(signer)) {
+                address = signer.getAddress();
+            } else {
+                address = (await this._chain.wrapSigner(signer)).getAddress();
+            }
+        }
+        return address;
+    }
+
 }

package/src/swaps/escrow_swaps/IEscrowSwap.ts

@@ -169,7 +169,7 @@ export abstract class IEscrowSwap<
      * @param abortSignal
      * @internal
      */
-    protected async watchdogWaitTillCommited(intervalSeconds?: number, abortSignal?: AbortSignal): Promise<boolean> {
+    protected async watchdogWaitTillCommited(intervalSeconds?: number, abortSignal?: AbortSignal): Promise<SwapCommitState | null> {
         if(this._data==null) throw new Error("Tried to await commitment but data is null, invalid state?");
 
         intervalSeconds ??= 5;
@@ -181,13 +181,15 @@ export abstract class IEscrowSwap<
                 if(
                     status?.type===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);
             }
         }
         if(abortSignal!=null) abortSignal.throwIfAborted();
-        return status?.type!==SwapCommitStateType.EXPIRED;
+        return status?.type===SwapCommitStateType.EXPIRED
+            ? null
+            : status;
     }
 
     /**

package/src/swaps/escrow_swaps/IEscrowSwapWrapper.ts

@@ -16,6 +16,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>;
 
@@ -65,6 +66,7 @@ export abstract class IEscrowSwapWrapper<
         chain: T["ChainInterface"],
         prices: ISwapPrice,
         tokens: WrapperCtorTokens,
+        lpApi: IntermediaryAPI,
         options: O,
         versionedContracts: {
             [version: string]: {
@@ -74,7 +76,7 @@ export abstract class IEscrowSwapWrapper<
         },
         events?: EventEmitter<{swapState: [ISwap]}>
     ) {
-        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, events);
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, lpApi, options, events);
         this._versionedContracts = versionedContracts;
     }
 

package/src/swaps/escrow_swaps/frombtc/IFromBTCLNWrapper.ts

@@ -15,6 +15,7 @@ import {UserError} from "../../../errors/UserError";
 import { sha256 } from "@noble/hashes/sha256";
 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>;
 
@@ -42,6 +43,7 @@ export abstract class IFromBTCLNWrapper<
      * @param tokens
      * @param versionedContracts
      * @param lnApi
+     * @param lpApi
      * @param options
      * @param events Instance to use for emitting events
      */
@@ -59,10 +61,11 @@ export abstract class IFromBTCLNWrapper<
             }
         },
         lnApi: LightningNetworkApi,
+        lpApi: IntermediaryAPI,
         options: O,
         events?: EventEmitter<{swapState: [IEscrowSwap]}>
     ) {
-        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, versionedContracts, events);
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, lpApi, options, versionedContracts, events);
         this.lnApi = lnApi;
     }