@atomiqlabs/sdk 7.0.12 → 8.0.8

package/dist/swapper/SwapperWithChain.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapperWithChain = void 0;
+const SwapType_1 = require("../enums/SwapType");
+const SwapPriceWithChain_1 = require("../prices/SwapPriceWithChain");
+const SwapperWithSigner_1 = require("./SwapperWithSigner");
+const UserError_1 = require("../errors/UserError");
+const Token_1 = require("../types/Token");
+/**
+ * Chain-specific wrapper around Swapper for a particular blockchain
+ * @category Core
+ */
+class SwapperWithChain {
+    get intermediaryDiscovery() {
+        return this.swapper.intermediaryDiscovery;
+    }
+    get mempoolApi() {
+        return this.swapper.mempoolApi;
+    }
+    get bitcoinRpc() {
+        return this.swapper.bitcoinRpc;
+    }
+    get bitcoinNetwork() {
+        return this.swapper.bitcoinNetwork;
+    }
+    get Utils() {
+        return this.swapper.Utils;
+    }
+    get SwapTypeInfo() {
+        return this.swapper.SwapTypeInfo;
+    }
+    constructor(swapper, chainIdentifier) {
+        this.swapper = swapper;
+        this.chainIdentifier = chainIdentifier;
+        this.prices = new SwapPriceWithChain_1.SwapPriceWithChain(swapper.prices, chainIdentifier);
+    }
+    createToBTCSwap(signer, tokenAddress, address, amount, exactIn, additionalParams, options) {
+        return this.swapper.createToBTCSwap(this.chainIdentifier, signer, tokenAddress, address, amount, exactIn, additionalParams, options);
+    }
+    createToBTCLNSwap(signer, tokenAddress, paymentRequest, additionalParams, options) {
+        return this.swapper.createToBTCLNSwap(this.chainIdentifier, signer, tokenAddress, paymentRequest, additionalParams, options);
+    }
+    createToBTCLNSwapViaLNURL(signer, tokenAddress, lnurlPay, amount, exactIn, additionalParams, options) {
+        return this.swapper.createToBTCLNSwapViaLNURL(this.chainIdentifier, signer, tokenAddress, lnurlPay, amount, exactIn, additionalParams, options);
+    }
+    createToBTCLNSwapViaInvoiceCreateService(signer, tokenAddress, service, amount, exactIn, additionalParams, options) {
+        return this.swapper.createToBTCLNSwapViaInvoiceCreateService(this.chainIdentifier, signer, tokenAddress, service, amount, exactIn, additionalParams, options);
+    }
+    createFromBTCSwap(signer, tokenAddress, amount, exactOut, additionalParams, options) {
+        return this.swapper.createFromBTCSwap(this.chainIdentifier, signer, tokenAddress, amount, exactOut, additionalParams, options);
+    }
+    createFromBTCLNSwap(signer, tokenAddress, amount, exactOut, additionalParams, options) {
+        return this.swapper.createFromBTCLNSwap(this.chainIdentifier, signer, tokenAddress, amount, exactOut, additionalParams, options);
+    }
+    createFromBTCLNSwapViaLNURL(signer, tokenAddress, lnurl, amount, exactOut, additionalParams) {
+        return this.swapper.createFromBTCLNSwapViaLNURL(this.chainIdentifier, signer, tokenAddress, lnurl, amount, exactOut, additionalParams);
+    }
+    createFromBTCLNSwapNew(signer, tokenAddress, amount, exactOut, additionalParams, options) {
+        return this.swapper.createFromBTCLNSwapNew(this.chainIdentifier, signer, tokenAddress, amount, exactOut, additionalParams, options);
+    }
+    createFromBTCLNSwapNewViaLNURL(signer, tokenAddress, lnurl, amount, exactOut, additionalParams, options) {
+        return this.swapper.createFromBTCLNSwapNewViaLNURL(this.chainIdentifier, signer, tokenAddress, lnurl, amount, exactOut, additionalParams, options);
+    }
+    createTrustedLNForGasSwap(signer, amount, trustedIntermediaryUrl) {
+        return this.swapper.createTrustedLNForGasSwap(this.chainIdentifier, signer, amount, trustedIntermediaryUrl);
+    }
+    createTrustedOnchainForGasSwap(signer, amount, refundAddress, trustedIntermediaryUrl) {
+        return this.swapper.createTrustedOnchainForGasSwap(this.chainIdentifier, signer, amount, refundAddress, trustedIntermediaryUrl);
+    }
+    /**
+     * 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.
+     * @deprecated Use swap() instead
+     *
+     * @param signer Smartchain (Solana, Starknet, etc.) address of the user
+     * @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(signer, srcToken, dstToken, amount, exactIn, addressLnurlLightningInvoice) {
+        return this.swapper.create(signer, srcToken, dstToken, amount, exactIn, addressLnurlLightningInvoice);
+    }
+    /**
+     * 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 SmartChain -> BTC-LN (lightning) swaps the passed amount is ignored and
+     *  invoice's pre-set amount is used instead, use LNURL-pay for dynamic amounts
+     *
+     * @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 src Source wallet/lnurl-withdraw of the swap
+     * @param dst Destination smart chain address, bitcoin on-chain address, lightning invoice, LNURL-pay
+     * @param options Options for the swap
+     */
+    swap(srcToken, dstToken, amount, exactIn, src, dst, options) {
+        if (typeof (srcToken) === "string")
+            srcToken = this.getToken(srcToken);
+        if (typeof (dstToken) === "string")
+            dstToken = this.getToken(dstToken);
+        return this.swapper.swap(srcToken, dstToken, amount, exactIn, src, dst, options);
+    }
+    /**
+     * Returns swaps that are in-progress and are claimable for the specific chain, optionally also for a specific signer's address
+     */
+    getAllSwaps(signer) {
+        return this.swapper.getAllSwaps(this.chainIdentifier, signer);
+    }
+    /**
+     * Returns swaps that are in-progress and are claimable for the specific chain, optionally also for a specific signer's address
+     */
+    getActionableSwaps(signer) {
+        return this.swapper.getActionableSwaps(this.chainIdentifier, signer);
+    }
+    /**
+     * Returns swaps that are refundable for the specific chain, optionally also for a specific signer's address
+     */
+    getRefundableSwaps(signer) {
+        return this.swapper.getRefundableSwaps(this.chainIdentifier, signer);
+    }
+    /**
+     * Returns swaps that are due to be claimed/settled manually for the specific chain,
+     *  optionally also for a specific signer's address
+     */
+    getClaimableSwaps(signer) {
+        return this.swapper.getClaimableSwaps(this.chainIdentifier, signer);
+    }
+    /**
+     * Returns swap with a specific id (identifier) on a specific chain and optionally with a signer
+     */
+    getSwapById(id, signer) {
+        return this.swapper.getSwapById(id, this.chainIdentifier, signer);
+    }
+    getToken(tickerOrAddress) {
+        //Btc tokens - BTC, BTCLN, BTC-LN
+        if (tickerOrAddress === "BTC")
+            return Token_1.BitcoinTokens.BTC;
+        if (tickerOrAddress === "BTCLN" || tickerOrAddress === "BTC-LN")
+            return Token_1.BitcoinTokens.BTCLN;
+        //Check if the ticker is in format <chainId>-<ticker>, i.e. SOLANA-USDC, STARKNET-WBTC
+        if (tickerOrAddress.includes("-")) {
+            const [chainId, ticker] = tickerOrAddress.split("-");
+            if (chainId !== this.chainIdentifier)
+                throw new UserError_1.UserError(`Invalid chainId specified in ticker: ${chainId}, swapper chainId: ${this.chainIdentifier}`);
+            const token = this.swapper.tokensByTicker[this.chainIdentifier]?.[ticker];
+            if (token == null)
+                throw new UserError_1.UserError(`Not found ticker: ${ticker} for chainId: ${chainId}`);
+            return token;
+        }
+        const chain = this.swapper.chains[this.chainIdentifier];
+        if (chain.chainInterface.isValidToken(tickerOrAddress)) {
+            //Try to find in known token addresses
+            const token = this.swapper.tokens[this.chainIdentifier]?.[tickerOrAddress];
+            if (token != null)
+                return token;
+        }
+        else {
+            //Check in known tickers
+            const token = this.swapper.tokensByTicker[this.chainIdentifier]?.[tickerOrAddress];
+            if (token != null)
+                return token;
+        }
+        throw new UserError_1.UserError(`Specified token address or ticker ${tickerOrAddress} not found for chainId: ${this.chainIdentifier}!`);
+    }
+    /**
+     * Synchronizes swaps from chain, this is usually ran when SDK is initialized, deletes expired quotes
+     */
+    async _syncSwaps(signer) {
+        return this.swapper._syncSwaps(this.chainIdentifier, signer);
+    }
+    supportsSwapType(swapType) {
+        return this.swapper.supportsSwapType(this.chainIdentifier, swapType);
+    }
+    getSwapType(srcToken, dstToken) {
+        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(srcToken, dstToken) {
+        return this.swapper.getSwapLimits(srcToken, dstToken);
+    }
+    /**
+     * Returns a set of supported tokens by all the intermediaries offering a specific swap service
+     *
+     * @param _swapType Swap service type to check supported tokens for
+     */
+    getSupportedTokens(_swapType) {
+        const tokens = [];
+        this.intermediaryDiscovery.intermediaries.forEach(lp => {
+            let swapType = _swapType;
+            if (swapType === SwapType_1.SwapType.FROM_BTCLN && this.supportsSwapType(SwapType_1.SwapType.FROM_BTCLN_AUTO))
+                swapType = SwapType_1.SwapType.FROM_BTCLN_AUTO;
+            if (swapType === SwapType_1.SwapType.FROM_BTC && this.supportsSwapType(SwapType_1.SwapType.SPV_VAULT_FROM_BTC))
+                swapType = SwapType_1.SwapType.SPV_VAULT_FROM_BTC;
+            const chainTokens = lp.services[swapType]?.chainTokens?.[this.chainIdentifier];
+            if (chainTokens == null)
+                return;
+            for (let tokenAddress of chainTokens) {
+                const token = this.swapper.tokens?.[this.chainIdentifier]?.[tokenAddress];
+                if (token != null)
+                    tokens.push(token);
+            }
+        });
+        return tokens;
+    }
+    /**
+     * Returns the set of supported tokens by all the intermediaries we know of offering a specific swapType service
+     *
+     * @param swapType Specific swap type for which to obtain supported tokens
+     */
+    getSupportedTokenAddresses(swapType) {
+        const set = new Set();
+        this.intermediaryDiscovery.intermediaries.forEach(lp => {
+            const chainTokens = lp.services[swapType]?.chainTokens?.[this.chainIdentifier];
+            if (chainTokens == null)
+                return;
+            chainTokens.forEach(token => set.add(token));
+        });
+        return set;
+    }
+    /**
+     * 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, input) {
+        if ((0, Token_1.isSCToken)(token)) {
+            const result = [];
+            if (input) {
+                //TO_BTC or TO_BTCLN
+                if (this.getSupportedTokenAddresses(SwapType_1.SwapType.TO_BTCLN).has(token.address)) {
+                    result.push(Token_1.BitcoinTokens.BTCLN);
+                }
+                if (this.getSupportedTokenAddresses(SwapType_1.SwapType.TO_BTC).has(token.address)) {
+                    result.push(Token_1.BitcoinTokens.BTC);
+                }
+            }
+            else {
+                //FROM_BTC or FROM_BTCLN
+                const fromLightningSwapType = this.supportsSwapType(SwapType_1.SwapType.FROM_BTCLN_AUTO) ? SwapType_1.SwapType.FROM_BTCLN_AUTO : SwapType_1.SwapType.FROM_BTCLN;
+                if (this.getSupportedTokenAddresses(fromLightningSwapType).has(token.address)) {
+                    result.push(Token_1.BitcoinTokens.BTCLN);
+                }
+                const fromOnchainSwapType = this.supportsSwapType(SwapType_1.SwapType.SPV_VAULT_FROM_BTC) ? SwapType_1.SwapType.SPV_VAULT_FROM_BTC : SwapType_1.SwapType.FROM_BTC;
+                if (this.getSupportedTokenAddresses(fromOnchainSwapType).has(token.address)) {
+                    result.push(Token_1.BitcoinTokens.BTC);
+                }
+            }
+            return result;
+        }
+        else {
+            if (input) {
+                if (token.lightning) {
+                    return this.getSupportedTokens(SwapType_1.SwapType.FROM_BTCLN);
+                }
+                else {
+                    return this.getSupportedTokens(SwapType_1.SwapType.FROM_BTC);
+                }
+            }
+            else {
+                if (token.lightning) {
+                    return this.getSupportedTokens(SwapType_1.SwapType.TO_BTCLN);
+                }
+                else {
+                    return this.getSupportedTokens(SwapType_1.SwapType.TO_BTC);
+                }
+            }
+        }
+    }
+    /**
+     * Creates a child swapper instance with a signer
+     *
+     * @param signer Signer to use for the new swapper instance
+     */
+    withChain(signer) {
+        return new SwapperWithSigner_1.SwapperWithSigner(this, signer);
+    }
+    ///////////////////////////////////
+    /// Deprecated
+    /**
+     * Returns swap bounds (minimums & maximums) for different swap types & tokens
+     * @deprecated Use getSwapLimits() instead!
+     */
+    getSwapBounds() {
+        return this.swapper.getSwapBounds(this.chainIdentifier);
+    }
+    /**
+     * Returns maximum possible swap amount
+     * @deprecated Use getSwapLimits() instead!
+     *
+     * @param type      Type of the swap
+     * @param token     Token of the swap
+     */
+    getMaximum(type, token) {
+        return this.swapper.getMaximum(this.chainIdentifier, type, token);
+    }
+    /**
+     * Returns minimum possible swap amount
+     * @deprecated Use getSwapLimits() instead!
+     *
+     * @param type      Type of swap
+     * @param token     Token of the swap
+     */
+    getMinimum(type, token) {
+        return this.swapper.getMinimum(this.chainIdentifier, type, token);
+    }
+}
+exports.SwapperWithChain = SwapperWithChain;

package/dist/swapper/SwapperWithSigner.d.ts

@@ -0,0 +1,178 @@
+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 } 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 declare 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>;
+    get intermediaryDiscovery(): IntermediaryDiscovery;
+    get mempoolApi(): MempoolApi;
+    get bitcoinRpc(): MempoolBitcoinRpc;
+    get bitcoinNetwork(): BTC_NETWORK;
+    get Utils(): SwapperUtils<T>;
+    get SwapTypeInfo(): {
+        readonly 2: {
+            readonly requiresInputWallet: true;
+            readonly requiresOutputWallet: false;
+            readonly supportsGasDrop: false;
+        };
+        readonly 3: {
+            readonly requiresInputWallet: true;
+            readonly requiresOutputWallet: false;
+            readonly supportsGasDrop: false;
+        };
+        readonly 0: {
+            readonly requiresInputWallet: false;
+            readonly requiresOutputWallet: true;
+            readonly supportsGasDrop: false;
+        };
+        readonly 1: {
+            readonly requiresInputWallet: false;
+            readonly requiresOutputWallet: true;
+            readonly supportsGasDrop: false;
+        };
+        readonly 6: {
+            readonly requiresInputWallet: true;
+            readonly requiresOutputWallet: false;
+            readonly supportsGasDrop: true;
+        };
+        readonly 7: {
+            readonly requiresInputWallet: false;
+            readonly requiresOutputWallet: false;
+            readonly supportsGasDrop: true;
+        };
+        readonly 4: {
+            readonly requiresInputWallet: false;
+            readonly requiresOutputWallet: false;
+            readonly supportsGasDrop: false;
+        };
+        readonly 5: {
+            readonly requiresInputWallet: false;
+            readonly requiresOutputWallet: false;
+            readonly supportsGasDrop: false;
+        };
+    };
+    constructor(swapper: SwapperWithChain<T, ChainIdentifier>, signer: T[ChainIdentifier]["Signer"]);
+    createToBTCSwap(tokenAddress: string, address: string, amount: bigint, exactIn?: boolean, additionalParams?: Record<string, any>, options?: ToBTCOptions): Promise<SwapWithSigner<ToBTCSwap<T[ChainIdentifier]>>>;
+    createToBTCLNSwap(tokenAddress: string, paymentRequest: string, additionalParams?: Record<string, any>, options?: ToBTCLNOptions & {
+        comment?: string;
+    }): Promise<SwapWithSigner<ToBTCLNSwap<T[ChainIdentifier]>>>;
+    createToBTCLNSwapViaLNURL(tokenAddress: string, lnurlPay: string | LNURLPay, amount: bigint, exactIn?: boolean, additionalParams?: Record<string, any>, options?: ToBTCLNOptions): Promise<SwapWithSigner<ToBTCLNSwap<T[ChainIdentifier]>>>;
+    createFromBTCSwap(tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any>, options?: FromBTCOptions): Promise<SwapWithSigner<FromBTCSwap<T[ChainIdentifier]>>>;
+    createFromBTCLNSwap(tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any>, options?: FromBTCLNOptions): Promise<SwapWithSigner<FromBTCLNSwap<T[ChainIdentifier]>>>;
+    createFromBTCLNSwapViaLNURL(tokenAddress: string, lnurl: string | LNURLWithdraw, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any>): Promise<SwapWithSigner<FromBTCLNSwap<T[ChainIdentifier]>>>;
+    createFromBTCLNSwapNew(tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any>, options?: FromBTCLNAutoOptions): Promise<SwapWithSigner<FromBTCLNAutoSwap<T[ChainIdentifier]>>>;
+    createFromBTCLNSwapNewViaLNURL(tokenAddress: string, lnurl: string | LNURLWithdraw, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any>, options?: FromBTCLNAutoOptions): Promise<SwapWithSigner<FromBTCLNAutoSwap<T[ChainIdentifier]>>>;
+    createTrustedLNForGasSwap(amount: bigint, trustedIntermediaryUrl?: string): Promise<LnForGasSwap<T[ChainIdentifier]>>;
+    createTrustedOnchainForGasSwap(amount: bigint, refundAddress?: string, trustedIntermediaryUrl?: string): Promise<OnchainForGasSwap<T[ChainIdentifier]>>;
+    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]>>;
+    /**
+     * 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]>[]>;
+    /**
+     * 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]>[]>;
+    /**
+     * Returns swaps that are refundable for the specific chain, optionally also for a specific signer's address
+     */
+    getRefundableSwaps(): Promise<IToBTCSwap<T[ChainIdentifier]>[]>;
+    /**
+     * Returns swap with a specific id (identifier) on a specific chain and optionally with a signer
+     */
+    getSwapById(id: string): Promise<ISwap<T[ChainIdentifier]>>;
+    /**
+     * Synchronizes swaps from chain, this is usually ran when SDK is initialized, deletes expired quotes
+     */
+    _syncSwaps(): Promise<void>;
+    supportsSwapType<Type extends SwapType>(swapType: Type): SupportsSwapType<T[ChainIdentifier], Type>;
+    /**
+     * 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;
+    /**
+     * 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>;
+        };
+    };
+    /**
+     * 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>[];
+    /**
+     * Returns swap bounds (minimums & maximums) for different swap types & tokens
+     * @deprecated Use getSwapLimits() instead!
+     */
+    getSwapBounds(): SwapBounds;
+    /**
+     * 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;
+    /**
+     * 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;
+}

package/dist/swapper/SwapperWithSigner.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapperWithSigner = void 0;
+const SwapWithSigner_1 = require("../types/SwapWithSigner");
+/**
+ * Chain and signer-specific wrapper for automatic signer injection into swap methods
+ * @category Core
+ */
+class SwapperWithSigner {
+    get prices() {
+        return this.swapper.prices;
+    }
+    get intermediaryDiscovery() {
+        return this.swapper.intermediaryDiscovery;
+    }
+    get mempoolApi() {
+        return this.swapper.mempoolApi;
+    }
+    get bitcoinRpc() {
+        return this.swapper.bitcoinRpc;
+    }
+    get bitcoinNetwork() {
+        return this.swapper.bitcoinNetwork;
+    }
+    get Utils() {
+        return this.swapper.Utils;
+    }
+    get SwapTypeInfo() {
+        return this.swapper.SwapTypeInfo;
+    }
+    constructor(swapper, signer) {
+        this.swapper = swapper;
+        this.signer = signer;
+        this.chainIdentifier = swapper.chainIdentifier;
+    }
+    createToBTCSwap(tokenAddress, address, amount, exactIn, additionalParams, options) {
+        return this.swapper.createToBTCSwap(this.signer.getAddress(), tokenAddress, address, amount, exactIn, additionalParams, options)
+            .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
+    }
+    createToBTCLNSwap(tokenAddress, paymentRequest, additionalParams, options) {
+        return this.swapper.createToBTCLNSwap(this.signer.getAddress(), tokenAddress, paymentRequest, additionalParams, options)
+            .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
+    }
+    createToBTCLNSwapViaLNURL(tokenAddress, lnurlPay, amount, exactIn, additionalParams, options) {
+        return this.swapper.createToBTCLNSwapViaLNURL(this.signer.getAddress(), tokenAddress, lnurlPay, amount, exactIn, additionalParams, options)
+            .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
+    }
+    createFromBTCSwap(tokenAddress, amount, exactOut, additionalParams, options) {
+        return this.swapper.createFromBTCSwap(this.signer.getAddress(), tokenAddress, amount, exactOut, additionalParams, options)
+            .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
+    }
+    createFromBTCLNSwap(tokenAddress, amount, exactOut, additionalParams, options) {
+        return this.swapper.createFromBTCLNSwap(this.signer.getAddress(), tokenAddress, amount, exactOut, additionalParams, options)
+            .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
+    }
+    createFromBTCLNSwapViaLNURL(tokenAddress, lnurl, amount, exactOut, additionalParams) {
+        return this.swapper.createFromBTCLNSwapViaLNURL(this.signer.getAddress(), tokenAddress, lnurl, amount, exactOut, additionalParams)
+            .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
+    }
+    createFromBTCLNSwapNew(tokenAddress, amount, exactOut, additionalParams, options) {
+        return this.swapper.createFromBTCLNSwapNew(this.signer.getAddress(), tokenAddress, amount, exactOut, additionalParams, options)
+            .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
+    }
+    createFromBTCLNSwapNewViaLNURL(tokenAddress, lnurl, amount, exactOut, additionalParams, options) {
+        return this.swapper.createFromBTCLNSwapNewViaLNURL(this.signer.getAddress(), tokenAddress, lnurl, amount, exactOut, additionalParams, options)
+            .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
+    }
+    createTrustedLNForGasSwap(amount, trustedIntermediaryUrl) {
+        return this.swapper.createTrustedLNForGasSwap(this.signer.getAddress(), amount, trustedIntermediaryUrl);
+    }
+    createTrustedOnchainForGasSwap(amount, refundAddress, trustedIntermediaryUrl) {
+        return this.swapper.createTrustedOnchainForGasSwap(this.signer.getAddress(), amount, refundAddress, trustedIntermediaryUrl);
+    }
+    /**
+     * 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, dstToken, amount, exactIn, addressLnurlLightningInvoice) {
+        return this.swapper.create(this.signer.getAddress(), srcToken, dstToken, amount, exactIn, addressLnurlLightningInvoice)
+            .then(swap => (0, SwapWithSigner_1.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() {
+        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() {
+        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() {
+        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) {
+        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() {
+        return this.swapper._syncSwaps(this.signer.getAddress());
+    }
+    supportsSwapType(swapType) {
+        return this.swapper.supportsSwapType(swapType);
+    }
+    getSwapType(srcToken, dstToken) {
+        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(srcToken, dstToken) {
+        return this.swapper.getSwapLimits(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, input) {
+        return this.swapper.getSwapCounterTokens(token, input);
+    }
+    ///////////////////////////////////
+    /// Deprecated
+    /**
+     * Returns swap bounds (minimums & maximums) for different swap types & tokens
+     * @deprecated Use getSwapLimits() instead!
+     */
+    getSwapBounds() {
+        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, token) {
+        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, token) {
+        return this.swapper.getMinimum(type, token);
+    }
+}
+exports.SwapperWithSigner = SwapperWithSigner;