@atomiqlabs/sdk 7.0.12 → 8.0.8

package/src/swapper/SwapperWithSigner.ts

@@ -0,0 +1,300 @@
+import {IntermediaryDiscovery, SwapBounds} from "../intermediaries/IntermediaryDiscovery";
+import {SwapType} from "../enums/SwapType";
+import {LnForGasSwap} from "../swaps/trusted/ln/LnForGasSwap";
+import {ISwap} from "../swaps/ISwap";
+import {IToBTCSwap} from "../swaps/escrow_swaps/tobtc/IToBTCSwap";
+import {ChainIds, MultiChain, SupportsSwapType} from "./Swapper";
+import {FromBTCLNSwap} from "../swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap";
+import {FromBTCSwap} from "../swaps/escrow_swaps/frombtc/onchain/FromBTCSwap";
+import {ToBTCLNSwap} from "../swaps/escrow_swaps/tobtc/ln/ToBTCLNSwap";
+import {ToBTCSwap} from "../swaps/escrow_swaps/tobtc/onchain/ToBTCSwap";
+import {SwapPriceWithChain} from "../prices/SwapPriceWithChain";
+import {MempoolApi} from "../bitcoin/mempool/MempoolApi";
+import {MempoolBitcoinRpc} from "../bitcoin/mempool/MempoolBitcoinRpc";
+import {BTC_NETWORK} from "@scure/btc-signer/utils";
+import {ToBTCOptions} from "../swaps/escrow_swaps/tobtc/onchain/ToBTCWrapper";
+import {ToBTCLNOptions} from "../swaps/escrow_swaps/tobtc/ln/ToBTCLNWrapper";
+import {FromBTCOptions} from "../swaps/escrow_swaps/frombtc/onchain/FromBTCWrapper";
+import {FromBTCLNOptions} from "../swaps/escrow_swaps/frombtc/ln/FromBTCLNWrapper";
+import {SwapperUtils} from "./SwapperUtils";
+import {SpvFromBTCSwap} from "../swaps/spv_swaps/SpvFromBTCSwap";
+import {SwapperWithChain} from "./SwapperWithChain";
+import {SwapWithSigner, wrapSwapWithSigner} from "../types/SwapWithSigner";
+import {OnchainForGasSwap} from "../swaps/trusted/onchain/OnchainForGasSwap";
+import {FromBTCLNAutoSwap} from "../swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoSwap";
+import {FromBTCLNAutoOptions} from "../swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoWrapper";
+import {TokenAmount} from "../types/TokenAmount";
+import {BtcToken, SCToken, Token} from "../types/Token";
+import {LNURLWithdraw} from "../types/lnurl/LNURLWithdraw";
+import {LNURLPay} from "../types/lnurl/LNURLPay";
+
+/**
+ * Chain and signer-specific wrapper for automatic signer injection into swap methods
+ * @category Core
+ */
+export class SwapperWithSigner<T extends MultiChain, ChainIdentifier extends ChainIds<T>> {
+
+    readonly chainIdentifier: ChainIdentifier;
+    readonly swapper: SwapperWithChain<T, ChainIdentifier>;
+    readonly signer: T[ChainIdentifier]["Signer"];
+
+    get prices(): SwapPriceWithChain<T, ChainIdentifier> {
+        return this.swapper.prices;
+    }
+    get intermediaryDiscovery(): IntermediaryDiscovery {
+        return this.swapper.intermediaryDiscovery;
+    }
+    get mempoolApi(): MempoolApi {
+        return this.swapper.mempoolApi;
+    }
+    get bitcoinRpc(): MempoolBitcoinRpc {
+        return this.swapper.bitcoinRpc;
+    }
+    get bitcoinNetwork(): BTC_NETWORK {
+        return this.swapper.bitcoinNetwork;
+    }
+    get Utils(): SwapperUtils<T> {
+        return this.swapper.Utils;
+    }
+    get SwapTypeInfo() {
+        return this.swapper.SwapTypeInfo;
+    }
+
+    constructor(swapper: SwapperWithChain<T, ChainIdentifier>, signer: T[ChainIdentifier]["Signer"]) {
+        this.swapper = swapper;
+        this.signer = signer;
+        this.chainIdentifier = swapper.chainIdentifier;
+    }
+
+    createToBTCSwap(
+        tokenAddress: string,
+        address: string,
+        amount: bigint,
+        exactIn?: boolean,
+        additionalParams?: Record<string, any>,
+        options?: ToBTCOptions
+    ): Promise<SwapWithSigner<ToBTCSwap<T[ChainIdentifier]>>> {
+        return this.swapper.createToBTCSwap(this.signer.getAddress(), tokenAddress, address, amount, exactIn, additionalParams, options)
+            .then(swap => wrapSwapWithSigner(swap, this.signer));
+    }
+
+    createToBTCLNSwap(
+        tokenAddress: string,
+        paymentRequest: string,
+        additionalParams?: Record<string, any>,
+        options?: ToBTCLNOptions & {comment?: string}
+    ): Promise<SwapWithSigner<ToBTCLNSwap<T[ChainIdentifier]>>> {
+        return this.swapper.createToBTCLNSwap(this.signer.getAddress(), tokenAddress, paymentRequest, additionalParams, options)
+            .then(swap => wrapSwapWithSigner(swap, this.signer));
+    }
+
+    createToBTCLNSwapViaLNURL(
+        tokenAddress: string,
+        lnurlPay: string | LNURLPay,
+        amount: bigint,
+        exactIn?: boolean,
+        additionalParams?: Record<string, any>,
+        options?: ToBTCLNOptions
+    ): Promise<SwapWithSigner<ToBTCLNSwap<T[ChainIdentifier]>>> {
+        return this.swapper.createToBTCLNSwapViaLNURL(this.signer.getAddress(), tokenAddress, lnurlPay, amount, exactIn, additionalParams, options)
+            .then(swap => wrapSwapWithSigner(swap, this.signer));
+    }
+
+    createFromBTCSwap(
+        tokenAddress: string,
+        amount: bigint,
+        exactOut?: boolean,
+        additionalParams?: Record<string, any>,
+        options?: FromBTCOptions
+    ): Promise<SwapWithSigner<FromBTCSwap<T[ChainIdentifier]>>> {
+        return this.swapper.createFromBTCSwap(this.signer.getAddress(), tokenAddress, amount, exactOut, additionalParams, options)
+            .then(swap => wrapSwapWithSigner(swap, this.signer));
+    }
+
+    createFromBTCLNSwap(
+        tokenAddress: string,
+        amount: bigint,
+        exactOut?: boolean,
+        additionalParams?: Record<string, any>,
+        options?: FromBTCLNOptions
+    ): Promise<SwapWithSigner<FromBTCLNSwap<T[ChainIdentifier]>>> {
+        return this.swapper.createFromBTCLNSwap(this.signer.getAddress(), tokenAddress, amount, exactOut, additionalParams, options)
+            .then(swap => wrapSwapWithSigner(swap, this.signer));
+    }
+
+    createFromBTCLNSwapViaLNURL(
+        tokenAddress: string,
+        lnurl: string | LNURLWithdraw,
+        amount: bigint,
+        exactOut?: boolean,
+        additionalParams?: Record<string, any>
+    ): Promise<SwapWithSigner<FromBTCLNSwap<T[ChainIdentifier]>>> {
+        return this.swapper.createFromBTCLNSwapViaLNURL(this.signer.getAddress(), tokenAddress, lnurl, amount, exactOut, additionalParams)
+            .then(swap => wrapSwapWithSigner(swap, this.signer));
+    }
+
+    createFromBTCLNSwapNew(
+        tokenAddress: string,
+        amount: bigint,
+        exactOut?: boolean,
+        additionalParams?: Record<string, any>,
+        options?: FromBTCLNAutoOptions
+    ): Promise<SwapWithSigner<FromBTCLNAutoSwap<T[ChainIdentifier]>>> {
+        return this.swapper.createFromBTCLNSwapNew(this.signer.getAddress(), tokenAddress, amount, exactOut, additionalParams, options)
+            .then(swap => wrapSwapWithSigner(swap, this.signer));
+    }
+
+    createFromBTCLNSwapNewViaLNURL(
+        tokenAddress: string,
+        lnurl: string | LNURLWithdraw,
+        amount: bigint,
+        exactOut?: boolean,
+        additionalParams?: Record<string, any>,
+        options?: FromBTCLNAutoOptions
+    ): Promise<SwapWithSigner<FromBTCLNAutoSwap<T[ChainIdentifier]>>> {
+        return this.swapper.createFromBTCLNSwapNewViaLNURL(this.signer.getAddress(), tokenAddress, lnurl, amount, exactOut, additionalParams, options)
+            .then(swap => wrapSwapWithSigner(swap, this.signer));
+    }
+
+    createTrustedLNForGasSwap(amount: bigint, trustedIntermediaryUrl?: string): Promise<LnForGasSwap<T[ChainIdentifier]>> {
+        return this.swapper.createTrustedLNForGasSwap(this.signer.getAddress(), amount, trustedIntermediaryUrl);
+    }
+
+    createTrustedOnchainForGasSwap(amount: bigint, refundAddress?: string, trustedIntermediaryUrl?: string): Promise<OnchainForGasSwap<T[ChainIdentifier]>> {
+        return this.swapper.createTrustedOnchainForGasSwap(this.signer.getAddress(), amount, refundAddress, trustedIntermediaryUrl);
+    }
+
+    create(srcToken: BtcToken<true>, dstToken: SCToken<ChainIdentifier>, amount: bigint, exactIn: boolean, lnurlWithdraw?: string | LNURLWithdraw): Promise<(SupportsSwapType<T[ChainIdentifier], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoSwap<T[ChainIdentifier]> : FromBTCLNSwap<T[ChainIdentifier]>)>;
+    create(srcToken: BtcToken<false>, dstToken: SCToken<ChainIdentifier>, amount: bigint, exactIn: boolean): Promise<(SupportsSwapType<T[ChainIdentifier], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCSwap<T[ChainIdentifier]> : FromBTCSwap<T[ChainIdentifier]>)>;
+    create(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<false>, amount: bigint, exactIn: boolean, address: string): Promise<ToBTCSwap<T[ChainIdentifier]>>;
+    create(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<true>, amount: bigint, exactIn: boolean, lnurlPay: string | LNURLPay): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    create(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<true>, amount: bigint, exactIn: false, lightningInvoice: string | LNURLWithdraw | LNURLPay): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    /**
+     * Creates a swap from srcToken to dstToken, of a specific token amount, either specifying input amount (exactIn=true)
+     *  or output amount (exactIn=false), NOTE: For regular -> BTC-LN (lightning) swaps the passed amount is ignored and
+     *  invoice's pre-set amount is used instead.
+     *
+     * @param srcToken Source token of the swap, user pays this token
+     * @param dstToken Destination token of the swap, user receives this token
+     * @param amount Amount of the swap
+     * @param exactIn Whether the amount specified is an input amount (exactIn=true) or an output amount (exactIn=false)
+     * @param addressLnurlLightningInvoice Bitcoin on-chain address, lightning invoice, LNURL-pay to pay or
+     *  LNURL-withdrawal to withdraw money from
+     */
+    create(srcToken: Token<ChainIdentifier>, dstToken: Token<ChainIdentifier>, amount: bigint, exactIn: boolean, addressLnurlLightningInvoice?: string | LNURLWithdraw | LNURLPay): Promise<SwapWithSigner<ISwap<T[ChainIdentifier]>>> {
+        return this.swapper.create(this.signer.getAddress(), srcToken as any, dstToken as any, amount, exactIn, addressLnurlLightningInvoice as any)
+            .then(swap => wrapSwapWithSigner(swap, this.signer));
+    }
+
+    /**
+     * Returns swaps that are in-progress and are claimable for the specific chain, optionally also for a specific signer's address
+     */
+    getAllSwaps(): Promise<ISwap<T[ChainIdentifier]>[]> {
+        return this.swapper.getAllSwaps(this.signer.getAddress());
+    }
+
+    /**
+     * Returns swaps that are in-progress and are claimable for the specific chain, optionally also for a specific signer's address
+     */
+    getActionableSwaps(): Promise<ISwap<T[ChainIdentifier]>[]> {
+        return this.swapper.getActionableSwaps(this.signer.getAddress());
+    }
+
+    /**
+     * Returns swaps that are refundable for the specific chain, optionally also for a specific signer's address
+     */
+    getRefundableSwaps(): Promise<IToBTCSwap<T[ChainIdentifier]>[]> {
+        return this.swapper.getRefundableSwaps(this.signer.getAddress());
+    }
+
+    /**
+     * Returns swap with a specific id (identifier) on a specific chain and optionally with a signer
+     */
+    getSwapById(id: string): Promise<ISwap<T[ChainIdentifier]>> {
+        return this.swapper.getSwapById(id, this.signer.getAddress());
+    }
+
+    /**
+     * Synchronizes swaps from chain, this is usually ran when SDK is initialized, deletes expired quotes
+     */
+    async _syncSwaps(): Promise<void> {
+        return this.swapper._syncSwaps(this.signer.getAddress());
+    }
+
+    supportsSwapType<
+        Type extends SwapType
+    >(swapType: Type): SupportsSwapType<T[ChainIdentifier], Type> {
+        return this.swapper.supportsSwapType(swapType);
+    }
+
+    /**
+     * Returns type of the swap based on input and output tokens specified
+     *
+     * @param srcToken
+     * @param dstToken
+     */
+    getSwapType(srcToken: BtcToken<true>, dstToken: SCToken<ChainIdentifier>): (SupportsSwapType<T[ChainIdentifier], SwapType.FROM_BTCLN_AUTO> extends true ? SwapType.FROM_BTCLN_AUTO : SwapType.FROM_BTCLN);
+    getSwapType(srcToken: BtcToken<false>, dstToken: SCToken<ChainIdentifier>): (SupportsSwapType<T[ChainIdentifier], SwapType.SPV_VAULT_FROM_BTC> extends true ? SwapType.SPV_VAULT_FROM_BTC : SwapType.FROM_BTC);
+    getSwapType(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<false>): SwapType.TO_BTC;
+    getSwapType(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<true>): SwapType.TO_BTCLN;
+    getSwapType(srcToken: Token<ChainIdentifier>, dstToken: Token<ChainIdentifier>): SwapType.FROM_BTCLN_AUTO | SwapType.FROM_BTCLN | SwapType.SPV_VAULT_FROM_BTC | SwapType.FROM_BTC | SwapType.TO_BTC | SwapType.TO_BTCLN;
+    getSwapType(srcToken: Token<ChainIdentifier>, dstToken: Token<ChainIdentifier>): SwapType.FROM_BTCLN_AUTO | SwapType.FROM_BTCLN | SwapType.SPV_VAULT_FROM_BTC | SwapType.FROM_BTC | SwapType.TO_BTC | SwapType.TO_BTCLN {
+        return this.swapper.getSwapType(srcToken, dstToken);
+    }
+
+    /**
+     * Returns minimum/maximum limits for inputs and outputs for a swap between given tokens
+     *
+     * @param srcToken
+     * @param dstToken
+     */
+    getSwapLimits<A extends Token<ChainIdentifier>, B extends Token<ChainIdentifier>>(srcToken: A, dstToken: B): {
+        input: {min: TokenAmount<string, A>, max?: TokenAmount<string, A>},
+        output: {min: TokenAmount<string, B>, max?: TokenAmount<string, B>}
+    } {
+        return this.swapper.getSwapLimits<A, B>(srcToken, dstToken);
+    }
+
+    /**
+     * Returns tokens that you can swap to (if input=true) from a given token,
+     *  or tokens that you can swap from (if input=false) to a given token
+     */
+    getSwapCounterTokens(token: Token, input: boolean): Token<ChainIdentifier>[] {
+        return this.swapper.getSwapCounterTokens(token, input);
+    }
+
+
+    ///////////////////////////////////
+    /// Deprecated
+
+    /**
+     * Returns swap bounds (minimums & maximums) for different swap types & tokens
+     * @deprecated Use getSwapLimits() instead!
+     */
+    getSwapBounds(): SwapBounds {
+        return this.swapper.getSwapBounds();
+    }
+
+    /**
+     * Returns maximum possible swap amount
+     * @deprecated Use getSwapLimits() instead!
+     *
+     * @param type      Type of the swap
+     * @param token     Token of the swap
+     */
+    getMaximum(type: SwapType, token: string): bigint {
+        return this.swapper.getMaximum(type, token);
+    }
+
+    /**
+     * Returns minimum possible swap amount
+     * @deprecated Use getSwapLimits() instead!
+     *
+     * @param type      Type of swap
+     * @param token     Token of the swap
+     */
+    getMinimum(type: SwapType, token: string): bigint {
+        return this.swapper.getMinimum(type, token);
+    }
+
+}

package/src/swaps/IAddressSwap.ts

@@ -0,0 +1,20 @@
+/**
+ * Type guard to check if an object is an IAddressSwap
+ * @category Swaps
+ */
+export function isIAddressSwap(obj: any): obj is IAddressSwap {
+    return obj!=null &&
+        typeof(obj.getAddress) === "function" &&
+        typeof(obj.getHyperlink) === "function";
+}
+
+/**
+ * Interface for swaps which require a user to send funds to a specific address
+ * @category Swaps
+ */
+export interface IAddressSwap {
+
+    getAddress(): string;
+    getHyperlink(): string;
+
+}

package/src/swaps/IBTCWalletSwap.ts

@@ -0,0 +1,77 @@
+import {IBitcoinWallet} from "../bitcoin/wallet/IBitcoinWallet";
+import {Transaction} from "@scure/btc-signer";
+import {
+    MinimalBitcoinWalletInterface,
+    MinimalBitcoinWalletInterfaceWithSigner
+} from "../bitcoin/wallet/MinimalBitcoinWalletInterface";
+import {TokenAmount} from "../types/TokenAmount";
+import {BtcToken} from "../types/Token";
+
+/**
+ * Type guard to check if an object is an IBTCWalletSwap
+ * @category Swaps
+ */
+export function isIBTCWalletSwap(obj: any): obj is IBTCWalletSwap {
+    return obj!=null &&
+        typeof(obj.getFundedPsbt) === "function" &&
+        typeof(obj.submitPsbt) === "function" &&
+        typeof(obj.estimateBitcoinFee) === "function" &&
+        typeof(obj.sendBitcoinTransaction) === "function" &&
+        typeof(obj.waitForBitcoinTransaction) === "function" &&
+        typeof(obj.getRequiredConfirmationsCount) === "function";
+}
+
+/**
+ * Interface for swaps requiring Bitcoin wallet interaction
+ * @category Swaps
+ */
+export interface IBTCWalletSwap {
+
+    /**
+     * Returns the PSBT that is already funded with wallet's UTXOs (runs a coin-selection algorithm to choose UTXOs to use),
+     *  also returns inputs indices that need to be signed by the wallet before submitting the PSBT back to the SDK with
+     *  `swap.submitPsbt()`
+     *
+     * @param _bitcoinWallet Sender's bitcoin wallet
+     * @param feeRate Optional fee rate for the transaction, needs to be at least as big as {minimumBtcFeeRate} field
+     * @param additionalOutputs additional outputs to add to the PSBT - can be used to collect fees from users
+     */
+    getFundedPsbt(
+        _bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface,
+        feeRate?: number,
+        additionalOutputs?: ({amount: bigint, outputScript: Uint8Array} | {amount: bigint, address: string})[]
+    ): Promise<{psbt: Transaction, psbtHex: string, psbtBase64: string, signInputs: number[]}>;
+
+    /**
+     * Submits a PSBT signed by the wallet back to the SDK
+     *
+     * @param psbt A psbt - either a Transaction object or a hex or base64 encoded PSBT string
+     */
+    submitPsbt(psbt: Transaction | string): Promise<string>;
+
+
+    estimateBitcoinFee(wallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number): Promise<TokenAmount<any, BtcToken<false>> | null>;
+
+
+    sendBitcoinTransaction(
+        wallet: IBitcoinWallet | MinimalBitcoinWalletInterfaceWithSigner,
+        feeRate?: number
+    ): Promise<string>;
+
+    /**
+     * Waits till the bitcoin transaction confirms
+     *
+     * @param updateCallback Callback called when txId is found, and also called with subsequent confirmations
+     * @param checkIntervalSeconds How often to check the bitcoin transaction
+     * @param abortSignal Abort signal
+     * @throws {Error} if in invalid state (must be CLAIM_COMMITED)
+     */
+    waitForBitcoinTransaction(
+        updateCallback?: (txId?: string, confirmations?: number, targetConfirmations?: number, txEtaMs?: number) => void,
+        checkIntervalSeconds?: number,
+        abortSignal?: AbortSignal,
+    ): Promise<string>;
+
+    getRequiredConfirmationsCount(): number;
+
+}

package/src/swaps/IClaimableSwap.ts

@@ -0,0 +1,30 @@
+import {ChainType} from "@atomiqlabs/base";
+import {ISwap} from "./ISwap";
+import {ISwapWrapper, SwapTypeDefinition} from "./ISwapWrapper";
+
+/**
+ * Type guard to check if an object is an IClaimableSwap
+ * @category Swaps
+ */
+export function isIClaimableSwap(obj: any): obj is IClaimableSwap {
+    return obj!=null &&
+        typeof(obj.isClaimable) === "function" &&
+        typeof(obj.txsClaim) === "function" &&
+        typeof(obj.claim) === "function";
+}
+
+/**
+ * Interface for swaps that can be claimed
+ * @category Swaps
+ */
+export interface IClaimableSwap<
+    T extends ChainType = ChainType,
+    D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, IClaimableSwap<T, D, S>> = SwapTypeDefinition<T, ISwapWrapper<T, any>, IClaimableSwap<T, any, any>>,
+    S extends number = number
+> extends ISwap<T, D, S> {
+
+    isClaimable(): boolean;
+    txsClaim(_signer?: T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
+    claim(_signer?: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string>;
+
+}

package/src/swaps/IClaimableSwapWrapper.ts

@@ -0,0 +1,9 @@
+import {ISwap} from "./ISwap";
+import {IClaimableSwap} from "./IClaimableSwap";
+
+
+export interface IClaimableSwapWrapper<T extends ISwap & IClaimableSwap = ISwap & IClaimableSwap> {
+
+    claimableSwapStates: T["state"][];
+
+}

package/src/swaps/IRefundableSwap.ts

@@ -0,0 +1,29 @@
+import {ChainType} from "@atomiqlabs/base";
+import {ISwap} from "./ISwap";
+import {ISwapWrapper, SwapTypeDefinition} from "./ISwapWrapper";
+
+/**
+ * Type guard to check if an object is an IRefundableSwap
+ * @category Swaps
+ */
+export function isIRefundableSwap(obj: any): obj is IRefundableSwap {
+    return typeof(obj.isRefundable) === "function" &&
+        typeof(obj.txsRefund) === "function" &&
+        typeof(obj.refund) === "function";
+}
+
+/**
+ * Interface for swaps that can be refunded
+ * @category Swaps
+ */
+export interface IRefundableSwap<
+    T extends ChainType = ChainType,
+    D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, IRefundableSwap<T, D, S>> = SwapTypeDefinition<T, ISwapWrapper<T, any>, IRefundableSwap<T, any, any>>,
+    S extends number = number
+> extends ISwap<T, D, S> {
+
+    isRefundable(): boolean;
+    txsRefund(_signer?: T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
+    refund(_signer?: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string>;
+
+}