@atomiqlabs/sdk 8.4.4 → 8.5.0

package/README.md

@@ -51,8 +51,8 @@ Set Solana & Starknet RPC URL to use
 
 ```typescript
 const solanaRpc = "https://api.mainnet-beta.solana.com";
-const starknetRpc = "https://starknet-mainnet.public.blastapi.io/rpc/v0_8";
-const citreaRpc = "https://rpc.testnet.citrea.xyz";
+const starknetRpc = "https://rpc.starknet.lava.build/"; //Alternatively: https://starknet.api.onfinality.io/public or https://api.zan.top/public/starknet-mainnet
+const citreaRpc = "https://rpc.mainnet.citrea.xyz";
 ```
 
 Create swapper factory, here we can pick and choose which chains we want to have supported in the SDK, ensure the "as const" keyword is used such that the typescript compiler can properly infer the types.
@@ -87,10 +87,10 @@ const swapper: TypedSwapper<SupportedChains> = Factory.newSwapper({
       rpcUrl: starknetRpc //You can also pass Provider object here           
     },
     CITREA: {
-      rpcUrl: citreaRpc, //You can also pass JsonApiProvider object here
+      rpcUrl: citreaRpc, //You can also pass JsonRpcApiProvider object here
     }
   },
-  bitcoinNetwork: BitcoinNetwork.TESTNET //or BitcoinNetwork.MAINNET, BitcoinNetwork.TESTNET4 - this also sets the network to use for Solana (solana devnet for bitcoin testnet) & Starknet (sepolia for bitcoin testnet)
+  bitcoinNetwork: BitcoinNetwork.MAINNET //or BitcoinNetwork.TESTNET3, BitcoinNetwork.TESTNET4 - this also sets the network to use for Solana (solana devnet for bitcoin testnet) & Starknet (sepolia for bitcoin testnet)
 });
 ```
 
@@ -122,7 +122,7 @@ const swapper: TypedSwapper<SupportedChains> = Factory.newSwapper({
             rpcUrl: citreaRpc, //You can also pass JsonApiProvider object here
         }
     },
-    bitcoinNetwork: BitcoinNetwork.TESTNET, //or BitcoinNetwork.MAINNET - this also sets the network to use for Solana (solana devnet for bitcoin testnet) & Starknet (sepolia for bitcoin testnet)
+    bitcoinNetwork: BitcoinNetwork.MAINNET //or BitcoinNetwork.TESTNET3, BitcoinNetwork.TESTNET4 - this also sets the network to use for Solana (solana devnet for bitcoin testnet) & Starknet (sepolia for bitcoin testnet)
     //The following lines are important for running on backend node.js,
     // because the SDK by default uses browser's Indexed DB
     swapStorage: chainId => new SqliteUnifiedStorage("CHAIN_"+chainId+".sqlite3"),
@@ -143,7 +143,7 @@ const wallet = new SolanaSigner(anchorWallet);
 
 ```typescript
 import {WalletAccount} from "starknet";
-import {StarknetSigner} from "@atomiqlabs/chain-starknet";
+import {StarknetBrowserSigner} from "@atomiqlabs/chain-starknet";
 //Browser, using get-starknet
 const swo = await connect();
 const wallet = new StarknetBrowserSigner(new WalletAccount(starknetRpc, swo.wallet));
@@ -1609,13 +1609,13 @@ Returns swaps that are ready to be claimed by the client, this can happen if cli
 
 ```typescript
 //Get the swaps
-const claimableSolanaSwaps = await solanaSwapper.getClaimableSwaps("SOLANA", solanaSigner.getAddress());
+const claimableSolanaSwaps = await swapper.getClaimableSwaps("SOLANA", solanaSigner.getAddress());
 //Claim all the claimable swaps
 for(let swap of claimableSolanaSwaps) {
     await swap.claim(solanaSigner);
 }
 //Get the swaps
-const claimableStarknetSwaps = await solanaSwapper.getClaimableSwaps("STARKNET", starknetSigner.getAddress());
+const claimableStarknetSwaps = await swapper.getClaimableSwaps("STARKNET", starknetSigner.getAddress());
 //Claim all the claimable swaps
 for(let swap of claimableStarknetSwaps) {
   await swap.claim(starknetSigner);

package/dist/enums/SwapSide.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Enum representing the side of the swap for querying available input/output tokens
+ *
+ * @category Core
+ */
+export declare enum SwapSide {
+    /**
+     * Represents input / source side of the swap
+     */
+    INPUT = 1,
+    /**
+     * Represents output / destination side of the swap
+     */
+    OUTPUT = 0
+}

package/dist/enums/SwapSide.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapSide = void 0;
+/**
+ * Enum representing the side of the swap for querying available input/output tokens
+ *
+ * @category Core
+ */
+var SwapSide;
+(function (SwapSide) {
+    /**
+     * Represents input / source side of the swap
+     */
+    SwapSide[SwapSide["INPUT"] = 1] = "INPUT";
+    /**
+     * Represents output / destination side of the swap
+     */
+    SwapSide[SwapSide["OUTPUT"] = 0] = "OUTPUT";
+})(SwapSide = exports.SwapSide || (exports.SwapSide = {}));

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export { CoinselectAddressTypes } from "./bitcoin/coinselect2";
 export * from "./enums/FeeType";
 export * from "./enums/SwapAmountType";
 export * from "./enums/SwapDirection";
+export * from "./enums/SwapSide";
 export * from "./enums/SwapType";
 export * from "./errors/IntermediaryError";
 export * from "./errors/RequestError";

package/dist/index.js

@@ -37,6 +37,7 @@ __exportStar(require("./bitcoin/wallet/SingleAddressBitcoinWallet"), exports);
 __exportStar(require("./enums/FeeType"), exports);
 __exportStar(require("./enums/SwapAmountType"), exports);
 __exportStar(require("./enums/SwapDirection"), exports);
+__exportStar(require("./enums/SwapSide"), exports);
 __exportStar(require("./enums/SwapType"), exports);
 __exportStar(require("./errors/IntermediaryError"), exports);
 __exportStar(require("./errors/RequestError"), exports);

package/dist/intermediaries/apis/IntermediaryAPI.d.ts

@@ -169,9 +169,9 @@ export type FromBTCInit = BaseFromBTCSwapInit & {
     sequence: bigint;
     claimerBounty: Promise<{
         feePerBlock: bigint;
-        safetyFactor: number;
+        safetyFactor: bigint;
         startTimestamp: bigint;
-        addBlock: number;
+        addBlock: bigint;
         addFee: bigint;
     }>;
 };

package/dist/intermediaries/apis/IntermediaryAPI.js

@@ -271,9 +271,9 @@ class IntermediaryAPI {
             claimerBounty: init.claimerBounty.then(claimerBounty => {
                 return {
                     feePerBlock: claimerBounty.feePerBlock.toString(10),
-                    safetyFactor: claimerBounty.safetyFactor,
+                    safetyFactor: claimerBounty.safetyFactor.toString(10),
                     startTimestamp: claimerBounty.startTimestamp.toString(10),
-                    addBlock: claimerBounty.addBlock,
+                    addBlock: claimerBounty.addBlock.toString(10),
                     addFee: claimerBounty.addFee.toString(10)
                 };
             }),

package/dist/storage/UnifiedSwapStorage.d.ts

@@ -36,6 +36,7 @@ declare const indexes: readonly [{
  * Simple index types for SDK swap storage
  *
  * @category Storage
+ * @useDeclaredType
  */
 export type UnifiedSwapStorageIndexes = typeof indexes;
 declare const compositeIndexes: readonly [{
@@ -55,6 +56,7 @@ declare const compositeIndexes: readonly [{
  * Composite index types for SDK swap storage
  *
  * @category Storage
+ * @useDeclaredType
  */
 export type UnifiedSwapStorageCompositeIndexes = typeof compositeIndexes;
 /**

package/dist/swapper/Swapper.d.ts

@@ -16,7 +16,6 @@ import { LnForGasWrapper } from "../swaps/trusted/ln/LnForGasWrapper";
 import { LnForGasSwap } from "../swaps/trusted/ln/LnForGasSwap";
 import { EventEmitter } from "events";
 import { Intermediary } from "../intermediaries/Intermediary";
-import { WrapperCtorTokens } from "../swaps/ISwapWrapper";
 import { SwapperWithChain } from "./SwapperWithChain";
 import { OnchainForGasSwap } from "../swaps/trusted/onchain/OnchainForGasSwap";
 import { OnchainForGasWrapper } from "../swaps/trusted/onchain/OnchainForGasWrapper";
@@ -39,6 +38,7 @@ import { LNURLWithdraw } from "../types/lnurl/LNURLWithdraw";
 import { LNURLPay } from "../types/lnurl/LNURLPay";
 import { NotNever } from "../utils/TypeUtils";
 import { LightningInvoiceCreateService } from "../types/wallets/LightningInvoiceCreateService";
+import { SwapSide } from "../enums/SwapSide";
 /**
  * Configuration options for the Swapper
  * @category Core
@@ -168,6 +168,17 @@ type MultiChainData<T extends MultiChain> = {
 type CtorMultiChainData<T extends MultiChain> = {
     [chainIdentifier in keyof T]: ChainData<T[chainIdentifier]>;
 };
+type SwapperCtorTokens<T extends MultiChain = MultiChain> = {
+    ticker: string;
+    name: string;
+    chains: {
+        [chainId in ChainIds<T>]?: {
+            address: string;
+            decimals: number;
+            displayDecimals?: number;
+        };
+    };
+}[];
 /**
  * Type extracting chain identifiers from a MultiChain type
  * @category Core
@@ -246,7 +257,7 @@ export declare class Swapper<T extends MultiChain> extends EventEmitter<{
     /**
      * @internal
      */
-    constructor(bitcoinRpc: BitcoinRpcWithAddressIndex<any>, lightningApi: LightningNetworkApi, bitcoinSynchronizer: (btcRelay: BtcRelay<any, any, any>) => RelaySynchronizer<any, any, any>, chainsData: CtorMultiChainData<T>, pricing: ISwapPrice<T>, tokens: WrapperCtorTokens<T>, messenger: Messenger, options?: SwapperOptions);
+    constructor(bitcoinRpc: BitcoinRpcWithAddressIndex<any>, lightningApi: LightningNetworkApi, bitcoinSynchronizer: (btcRelay: BtcRelay<any, any, any>) => RelaySynchronizer<any, any, any>, chainsData: CtorMultiChainData<T>, pricing: ISwapPrice<T>, tokens: SwapperCtorTokens<T>, messenger: Messenger, options?: SwapperOptions);
     private _init;
     private initPromise?;
     private initialized;
@@ -459,25 +470,25 @@ export declare class Swapper<T extends MultiChain> extends EventEmitter<{
     /**
      * @internal
      */
-    swap<C extends ChainIds<T>>(srcToken: BtcToken<true>, dstToken: SCToken<C>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string | LNURLWithdraw, dstSmartchainWallet: string, options?: (SupportsSwapType<T[C], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoOptions : FromBTCLNOptions)): Promise<(SupportsSwapType<T[C], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoSwap<T[C]> : FromBTCLNSwap<T[C]>)>;
+    swap<C extends ChainIds<T>>(srcToken: BtcToken<true> | "BTCLN" | "BTC-LN" | "LIGHTNING-BTC", dstToken: SCToken<C> | string, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string | LNURLWithdraw, dstSmartchainWallet: string, options?: (SupportsSwapType<T[C], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoOptions : FromBTCLNOptions)): Promise<(SupportsSwapType<T[C], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoSwap<T[C]> : FromBTCLNSwap<T[C]>)>;
     /**
      * @internal
      */
-    swap<C extends ChainIds<T>>(srcToken: BtcToken<false>, dstToken: SCToken<C>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string, dstSmartchainWallet: string, options?: (SupportsSwapType<T[C], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCOptions : FromBTCOptions)): Promise<(SupportsSwapType<T[C], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCSwap<T[C]> : FromBTCSwap<T[C]>)>;
+    swap<C extends ChainIds<T>>(srcToken: BtcToken<false> | "BTC" | "BITCOIN-BTC", dstToken: SCToken<C> | string, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string, dstSmartchainWallet: string, options?: (SupportsSwapType<T[C], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCOptions : FromBTCOptions)): Promise<(SupportsSwapType<T[C], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCSwap<T[C]> : FromBTCSwap<T[C]>)>;
     /**
      * @internal
      */
-    swap<C extends ChainIds<T>>(srcToken: SCToken<C>, dstToken: BtcToken<false>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstAddress: string, options?: ToBTCOptions): Promise<ToBTCSwap<T[C]>>;
+    swap<C extends ChainIds<T>>(srcToken: SCToken<C> | string, dstToken: BtcToken<false> | "BTC" | "BITCOIN-BTC", amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstAddress: string, options?: ToBTCOptions): Promise<ToBTCSwap<T[C]>>;
     /**
      * @internal
      */
-    swap<C extends ChainIds<T>>(srcToken: SCToken<C>, dstToken: BtcToken<true>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstLnurlPayOrInvoiceCreateService: string | LNURLPay | LightningInvoiceCreateService, options?: ToBTCLNOptions & {
+    swap<C extends ChainIds<T>>(srcToken: SCToken<C> | string, dstToken: BtcToken<true> | "BTCLN" | "BTC-LN" | "LIGHTNING-BTC", amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstLnurlPayOrInvoiceCreateService: string | LNURLPay | LightningInvoiceCreateService, options?: ToBTCLNOptions & {
         comment?: string;
     }): Promise<ToBTCLNSwap<T[C]>>;
     /**
      * @internal
      */
-    swap<C extends ChainIds<T>>(srcToken: SCToken<C>, dstToken: BtcToken<true>, amount: undefined, exactIn: false | SwapAmountType.EXACT_OUT, src: string, dstLightningInvoice: string, options?: ToBTCLNOptions): Promise<ToBTCLNSwap<T[C]>>;
+    swap<C extends ChainIds<T>>(srcToken: SCToken<C> | string, dstToken: BtcToken<true> | "BTCLN" | "BTC-LN" | "LIGHTNING-BTC", amount: undefined, exactIn: false | SwapAmountType.EXACT_OUT, src: string, dstLightningInvoice: string, options?: ToBTCLNOptions): Promise<ToBTCLNSwap<T[C]>>;
     /**
      * Creates a swap from srcToken to dstToken, of a specific token amount, either specifying input amount (if `exactIn=true`)
      *  or output amount (if `exactIn=false`), NOTE: For regular Smart chain -> BTC-LN (lightning) swaps the passed amount is ignored and
@@ -576,14 +587,9 @@ export declare class Swapper<T extends MultiChain> extends EventEmitter<{
      *  initiated after this blockheight
      */
     recoverSwaps<C extends ChainIds<T>>(chainId: C, signer: string, startBlockheight?: number): Promise<ISwap<T[C]>[]>;
-    /**
-     * Returns the {@link Token} object for a given token
-     *
-     * @param tickerOrAddress Token to return the object for, can use multiple formats:
-     *  - a) token ticker, such as `"BTC"`, `"SOL"`, etc.
-     *  - b) token ticker prefixed with smart chain identifier, such as `"SOLANA-SOL"`, `"SOLANA-USDC"`, etc.
-     *  - c) token address
-     */
+    getToken(ticker: "BTC" | "BITCOIN-BTC"): BtcToken<false>;
+    getToken(ticker: "BTCLN" | "BTC-LN" | "LIGHTNING-BTC"): BtcToken<true>;
+    getToken<ChainIdentifier extends ChainIds<T>>(ticker: `${ChainIdentifier}-${string}`): SCToken<ChainIdentifier>;
     getToken(tickerOrAddress: string): Token<ChainIds<T>>;
     /**
      * Creates a child swapper instance with a given smart chain
@@ -650,12 +656,12 @@ export declare class Swapper<T extends MultiChain> extends EventEmitter<{
      */
     getSwapLimits<C extends ChainIds<T>, A extends Token<C>, B extends Token<C>>(srcToken: A, dstToken: B): {
         input: {
-            min: TokenAmount<string, A>;
-            max?: TokenAmount<string, A>;
+            min: TokenAmount<A>;
+            max?: TokenAmount<A>;
         };
         output: {
-            min: TokenAmount<string, B>;
-            max?: TokenAmount<string, B>;
+            min: TokenAmount<B>;
+            max?: TokenAmount<B>;
         };
     };
     /**
@@ -663,7 +669,7 @@ export declare class Swapper<T extends MultiChain> extends EventEmitter<{
      *
      * @param input Whether to return input tokens or output tokens
      */
-    getSupportedTokens(input: boolean): Token[];
+    getSupportedTokens(input: SwapSide | boolean): Token[];
     /**
      * Returns a set of supported tokens by all the intermediaries offering a specific swap service
      *
@@ -681,6 +687,6 @@ export declare class Swapper<T extends MultiChain> extends EventEmitter<{
      * 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[];
+    getSwapCounterTokens(token: Token, input: SwapSide | boolean): Token[];
 }
 export {};

package/dist/swapper/Swapper.js

@@ -92,7 +92,9 @@ class Swapper extends events_1.EventEmitter {
                     name: tokenData.name,
                     decimals: chainData.decimals,
                     displayDecimals: chainData.displayDecimals,
-                    address: chainData.address
+                    address: chainData.address,
+                    equals: (other) => other.chainId === chainId && other.ticker === tokenData.ticker && other.address === chainData.address,
+                    toString: () => `${chainId}-${tokenData.ticker}`
                 };
             }
         }
@@ -100,49 +102,49 @@ class Swapper extends events_1.EventEmitter {
             this.emit("swapState", swap);
         };
         this._chains = (0, Utils_1.objectMap)(chainsData, (chainData, key) => {
-            const { swapContract, chainEvents, btcRelay, chainInterface, spvVaultContract, spvVaultWithdrawalDataConstructor } = chainData;
+            const { swapContract, chainEvents, btcRelay, chainInterface, spvVaultContract, spvVaultWithdrawalDataConstructor, chainId } = chainData;
             const synchronizer = bitcoinSynchronizer(btcRelay);
-            const storageHandler = swapStorage(storagePrefix + chainData.chainId);
+            const storageHandler = swapStorage(storagePrefix + chainId);
             const unifiedSwapStorage = new UnifiedSwapStorage_1.UnifiedSwapStorage(storageHandler, this.options.noSwapCache);
             const unifiedChainEvents = new UnifiedSwapEventListener_1.UnifiedSwapEventListener(unifiedSwapStorage, chainEvents);
             const wrappers = {};
-            wrappers[SwapType_1.SwapType.TO_BTCLN] = new ToBTCLNWrapper_1.ToBTCLNWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, tokens, chainData.swapDataConstructor, {
+            wrappers[SwapType_1.SwapType.TO_BTCLN] = new ToBTCLNWrapper_1.ToBTCLNWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
             });
-            wrappers[SwapType_1.SwapType.TO_BTC] = new ToBTCWrapper_1.ToBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, tokens, chainData.swapDataConstructor, this._bitcoinRpc, {
+            wrappers[SwapType_1.SwapType.TO_BTC] = new ToBTCWrapper_1.ToBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, this._bitcoinRpc, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
                 bitcoinNetwork: this._btcNetwork
             });
-            wrappers[SwapType_1.SwapType.FROM_BTCLN] = new FromBTCLNWrapper_1.FromBTCLNWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, tokens, chainData.swapDataConstructor, lightningApi, {
+            wrappers[SwapType_1.SwapType.FROM_BTCLN] = new FromBTCLNWrapper_1.FromBTCLNWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, lightningApi, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
                 unsafeSkipLnNodeCheck: this.bitcoinNetwork === base_1.BitcoinNetwork.TESTNET4 || this.bitcoinNetwork === base_1.BitcoinNetwork.REGTEST
             });
-            wrappers[SwapType_1.SwapType.FROM_BTC] = new FromBTCWrapper_1.FromBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, tokens, chainData.swapDataConstructor, btcRelay, synchronizer, this._bitcoinRpc, {
+            wrappers[SwapType_1.SwapType.FROM_BTC] = new FromBTCWrapper_1.FromBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, btcRelay, synchronizer, this._bitcoinRpc, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
                 bitcoinNetwork: this._btcNetwork
             });
-            wrappers[SwapType_1.SwapType.TRUSTED_FROM_BTCLN] = new LnForGasWrapper_1.LnForGasWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, pricing, tokens, {
+            wrappers[SwapType_1.SwapType.TRUSTED_FROM_BTCLN] = new LnForGasWrapper_1.LnForGasWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, pricing, this._tokens[chainId], {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout
             });
-            wrappers[SwapType_1.SwapType.TRUSTED_FROM_BTC] = new OnchainForGasWrapper_1.OnchainForGasWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, pricing, tokens, bitcoinRpc, {
+            wrappers[SwapType_1.SwapType.TRUSTED_FROM_BTC] = new OnchainForGasWrapper_1.OnchainForGasWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, pricing, this._tokens[chainId], bitcoinRpc, {
                 getRequestTimeout: this.options.getRequestTimeout,
                 postRequestTimeout: this.options.postRequestTimeout,
                 bitcoinNetwork: this._btcNetwork
             });
             if (spvVaultContract != null) {
-                wrappers[SwapType_1.SwapType.SPV_VAULT_FROM_BTC] = new SpvFromBTCWrapper_1.SpvFromBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, spvVaultContract, pricing, tokens, spvVaultWithdrawalDataConstructor, btcRelay, synchronizer, bitcoinRpc, {
+                wrappers[SwapType_1.SwapType.SPV_VAULT_FROM_BTC] = new SpvFromBTCWrapper_1.SpvFromBTCWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, spvVaultContract, pricing, this._tokens[chainId], spvVaultWithdrawalDataConstructor, btcRelay, synchronizer, bitcoinRpc, {
                     getRequestTimeout: this.options.getRequestTimeout,
                     postRequestTimeout: this.options.postRequestTimeout,
                     bitcoinNetwork: this._btcNetwork
                 });
             }
             if (swapContract.supportsInitWithoutClaimer) {
-                wrappers[SwapType_1.SwapType.FROM_BTCLN_AUTO] = new FromBTCLNAutoWrapper_1.FromBTCLNAutoWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, tokens, chainData.swapDataConstructor, lightningApi, this.messenger, {
+                wrappers[SwapType_1.SwapType.FROM_BTCLN_AUTO] = new FromBTCLNAutoWrapper_1.FromBTCLNAutoWrapper(key, unifiedSwapStorage, unifiedChainEvents, chainInterface, swapContract, pricing, this._tokens[chainId], chainData.swapDataConstructor, lightningApi, this.messenger, {
                     getRequestTimeout: this.options.getRequestTimeout,
                     postRequestTimeout: this.options.postRequestTimeout,
                     unsafeSkipLnNodeCheck: this.bitcoinNetwork === base_1.BitcoinNetwork.TESTNET4 || this.bitcoinNetwork === base_1.BitcoinNetwork.REGTEST
@@ -478,9 +480,6 @@ class Swapper extends events_1.EventEmitter {
         if (!this._chains[chainIdentifier].chainInterface.isValidAddress(signer, true))
             throw new Error("Invalid " + chainIdentifier + " address");
         signer = this._chains[chainIdentifier].chainInterface.normalizeAddress(signer);
-        options ??= {};
-        options.confirmationTarget ??= 3;
-        options.confirmations ??= 2;
         const amountData = {
             amount,
             token: tokenAddress,
@@ -502,7 +501,6 @@ class Swapper extends events_1.EventEmitter {
     async createToBTCLNSwap(chainIdentifier, signer, tokenAddress, paymentRequest, additionalParams = this.options.defaultAdditionalParameters, options) {
         if (this._chains[chainIdentifier] == null)
             throw new Error("Invalid chain identifier! Unknown chain: " + chainIdentifier);
-        options ??= {};
         if (paymentRequest.startsWith("lightning:"))
             paymentRequest = paymentRequest.substring(10);
         if (!this.Utils.isValidLightningInvoice(paymentRequest))
@@ -518,7 +516,6 @@ class Swapper extends events_1.EventEmitter {
             token: tokenAddress,
             exactIn: false
         };
-        options.expirySeconds ??= 5 * 24 * 3600;
         return this.createSwap(chainIdentifier, (candidates, abortSignal, chain) => chain.wrappers[SwapType_1.SwapType.TO_BTCLN].create(signer, paymentRequest, amountData, candidates, options, additionalParams, abortSignal), amountData, SwapType_1.SwapType.TO_BTCLN);
     }
     /**
@@ -546,8 +543,6 @@ class Swapper extends events_1.EventEmitter {
             token: tokenAddress,
             exactIn
         };
-        options ??= {};
-        options.expirySeconds ??= 5 * 24 * 3600;
         return this.createSwap(chainIdentifier, (candidates, abortSignal, chain) => chain.wrappers[SwapType_1.SwapType.TO_BTCLN].createViaLNURL(signer, typeof (lnurlPay) === "string" ? (lnurlPay.startsWith("lightning:") ? lnurlPay.substring(10) : lnurlPay) : lnurlPay.params, amountData, candidates, options, additionalParams, abortSignal), amountData, SwapType_1.SwapType.TO_BTCLN);
     }
     /**
@@ -568,13 +563,11 @@ class Swapper extends events_1.EventEmitter {
         if (!this._chains[chainIdentifier].chainInterface.isValidAddress(signer, true))
             throw new Error("Invalid " + chainIdentifier + " address");
         signer = this._chains[chainIdentifier].chainInterface.normalizeAddress(signer);
-        options ??= {};
         const amountData = {
             amount,
             token: tokenAddress,
             exactIn
         };
-        options.expirySeconds ??= 5 * 24 * 3600;
         return this.createSwap(chainIdentifier, (candidates, abortSignal, chain) => chain.wrappers[SwapType_1.SwapType.TO_BTCLN].createViaInvoiceCreateService(signer, Promise.resolve(service), amountData, candidates, options, additionalParams, abortSignal), amountData, SwapType_1.SwapType.TO_BTCLN);
     }
     /**
@@ -809,8 +802,8 @@ class Swapper extends events_1.EventEmitter {
         const srcToken = typeof (_srcToken) === "string" ? this.getToken(_srcToken) : _srcToken;
         const dstToken = typeof (_dstToken) === "string" ? this.getToken(_dstToken) : _dstToken;
         const amount = _amount == null ? null : (typeof (_amount) === "bigint" ? _amount : (0, Utils_1.fromDecimal)(_amount, exactIn ? srcToken.decimals : dstToken.decimals));
-        if (srcToken.chain === "BTC") {
-            if (dstToken.chain === "SC") {
+        if ((0, Token_1.isBtcToken)(srcToken)) {
+            if ((0, Token_1.isSCToken)(dstToken)) {
                 if (typeof (dst) !== "string")
                     throw new Error("Destination for BTC/BTC-LN -> smart chain swaps must be a smart chain address!");
                 if (amount == null)
@@ -841,8 +834,8 @@ class Swapper extends events_1.EventEmitter {
                 }
             }
         }
-        else {
-            if (dstToken.chain === "BTC") {
+        else if ((0, Token_1.isSCToken)(srcToken)) {
+            if ((0, Token_1.isBtcToken)(dstToken)) {
                 if (typeof (src) !== "string")
                     throw new Error("Source address for BTC/BTC-LN -> smart chain swaps must be a smart chain address!");
                 if (dstToken.lightning) {
@@ -1305,9 +1298,9 @@ class Swapper extends events_1.EventEmitter {
      */
     getToken(tickerOrAddress) {
         //Btc tokens - BTC, BTCLN, BTC-LN
-        if (tickerOrAddress === "BTC")
+        if (tickerOrAddress === "BTC" || tickerOrAddress === "BITCOIN-BTC")
             return Token_1.BitcoinTokens.BTC;
-        if (tickerOrAddress === "BTCLN" || tickerOrAddress === "BTC-LN")
+        if (tickerOrAddress === "BTCLN" || tickerOrAddress === "BTC-LN" || tickerOrAddress === "LIGHTNING-BTC")
             return Token_1.BitcoinTokens.BTCLN;
         //Check if the ticker is in format <chainId>-<ticker>, i.e. SOLANA-USDC, STARKNET-WBTC
         if (tickerOrAddress.includes("-")) {

package/dist/swapper/SwapperWithChain.d.ts

@@ -29,6 +29,7 @@ import { LNURLPay } from "../types/lnurl/LNURLPay";
 import { LightningInvoiceCreateService } from "../types/wallets/LightningInvoiceCreateService";
 import { Intermediary } from "../intermediaries/Intermediary";
 import { SwapTypeMapping } from "../utils/SwapUtils";
+import { SwapSide } from "../enums/SwapSide";
 /**
  * Chain-specific wrapper around Swapper for a particular blockchain
  *
@@ -244,25 +245,25 @@ export declare class SwapperWithChain<T extends MultiChain, ChainIdentifier exte
     /**
      * @internal
      */
-    swap(srcToken: BtcToken<true>, dstToken: SCToken<ChainIdentifier>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string | LNURLWithdraw, dstSmartchainWallet: string, options?: (SupportsSwapType<T[ChainIdentifier], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoOptions : FromBTCLNOptions)): Promise<SupportsSwapType<T[ChainIdentifier], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoSwap<T[ChainIdentifier]> : FromBTCLNSwap<T[ChainIdentifier]>>;
+    swap(srcToken: BtcToken<true> | "BTCLN" | "BTC-LN" | "LIGHTNING-BTC", dstToken: SCToken<ChainIdentifier>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string | LNURLWithdraw, dstSmartchainWallet: string, options?: (SupportsSwapType<T[ChainIdentifier], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoOptions : FromBTCLNOptions)): Promise<SupportsSwapType<T[ChainIdentifier], SwapType.FROM_BTCLN_AUTO> extends true ? FromBTCLNAutoSwap<T[ChainIdentifier]> : FromBTCLNSwap<T[ChainIdentifier]>>;
     /**
      * @internal
      */
-    swap(srcToken: BtcToken<false>, dstToken: SCToken<ChainIdentifier>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string, dstSmartchainWallet: string, options?: (SupportsSwapType<T[ChainIdentifier], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCOptions : FromBTCOptions)): Promise<(SupportsSwapType<T[ChainIdentifier], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCSwap<T[ChainIdentifier]> : FromBTCSwap<T[ChainIdentifier]>)>;
+    swap(srcToken: BtcToken<false> | "BTC" | "BITCOIN-BTC", dstToken: SCToken<ChainIdentifier>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: undefined | string, dstSmartchainWallet: string, options?: (SupportsSwapType<T[ChainIdentifier], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCOptions : FromBTCOptions)): Promise<(SupportsSwapType<T[ChainIdentifier], SwapType.SPV_VAULT_FROM_BTC> extends true ? SpvFromBTCSwap<T[ChainIdentifier]> : FromBTCSwap<T[ChainIdentifier]>)>;
     /**
      * @internal
      */
-    swap(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<false>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstAddress: string, options?: ToBTCOptions): Promise<ToBTCSwap<T[ChainIdentifier]>>;
+    swap(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<false> | "BTC" | "BITCOIN-BTC", amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstAddress: string, options?: ToBTCOptions): Promise<ToBTCSwap<T[ChainIdentifier]>>;
     /**
      * @internal
      */
-    swap(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<true>, amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstLnurlPayOrInvoiceCreateService: string | LNURLPay | LightningInvoiceCreateService, options?: ToBTCLNOptions & {
+    swap(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<true> | "BTCLN" | "BTC-LN" | "LIGHTNING-BTC", amount: bigint | string, exactIn: boolean | SwapAmountType, src: string, dstLnurlPayOrInvoiceCreateService: string | LNURLPay | LightningInvoiceCreateService, options?: ToBTCLNOptions & {
         comment?: string;
     }): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
     /**
      * @internal
      */
-    swap(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<true>, amount: undefined, exactIn: false | SwapAmountType.EXACT_OUT, src: string, dstLightningInvoice: string, options?: ToBTCLNOptions): Promise<ToBTCLNSwap<T[ChainIdentifier]>>;
+    swap(srcToken: SCToken<ChainIdentifier>, dstToken: BtcToken<true> | "BTCLN" | "BTC-LN" | "LIGHTNING-BTC", amount: undefined, exactIn: false | SwapAmountType.EXACT_OUT, src: string, dstLightningInvoice: string, options?: ToBTCLNOptions): 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 SmartChain -> BTC-LN (lightning) swaps the passed amount is ignored and
@@ -328,14 +329,9 @@ export declare class SwapperWithChain<T extends MultiChain, ChainIdentifier exte
      *  initiated after this blockheight
      */
     recoverSwaps(signer: string, startBlockheight?: number): Promise<ISwap<T[ChainIdentifier]>[]>;
-    /**
-     * Returns the {@link Token} object for a given token
-     *
-     * @param tickerOrAddress Token to return the object for, can use multiple formats:
-     *  - a) token ticker, such as `"BTC"`, `"SOL"`, etc.
-     *  - b) token ticker prefixed with smart chain identifier, such as `"SOLANA-SOL"`, `"SOLANA-USDC"`, etc.
-     *  - c) token address
-     */
+    getToken(ticker: "BTC" | "BITCOIN-BTC"): BtcToken<false>;
+    getToken(ticker: "BTCLN" | "BTC-LN" | "LIGHTNING-BTC"): BtcToken<true>;
+    getToken(ticker: `${ChainIdentifier}-${string}`): SCToken<ChainIdentifier>;
     getToken(tickerOrAddress: string): Token<ChainIdentifier>;
     /**
      * Returns whether the SDK supports a given swap type on this chain based on currently known LPs
@@ -374,12 +370,12 @@ export declare class SwapperWithChain<T extends MultiChain, ChainIdentifier exte
      */
     getSwapLimits<A extends Token<ChainIdentifier>, B extends Token<ChainIdentifier>>(srcToken: A, dstToken: B): {
         input: {
-            min: TokenAmount<string, A>;
-            max?: TokenAmount<string, A>;
+            min: TokenAmount<A>;
+            max?: TokenAmount<A>;
         };
         output: {
-            min: TokenAmount<string, B>;
-            max?: TokenAmount<string, B>;
+            min: TokenAmount<B>;
+            max?: TokenAmount<B>;
         };
     };
     /**
@@ -398,7 +394,7 @@ export declare class SwapperWithChain<T extends MultiChain, ChainIdentifier exte
      * 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>[];
+    getSwapCounterTokens(token: Token, input: SwapSide | boolean): Token<ChainIdentifier>[];
     /**
      * Creates a child swapper instance with a signer
      *

package/dist/swapper/SwapperWithChain.js

@@ -315,9 +315,9 @@ class SwapperWithChain {
      */
     getToken(tickerOrAddress) {
         //Btc tokens - BTC, BTCLN, BTC-LN
-        if (tickerOrAddress === "BTC")
+        if (tickerOrAddress === "BTC" || tickerOrAddress === "BITCOIN-BTC")
             return Token_1.BitcoinTokens.BTC;
-        if (tickerOrAddress === "BTCLN" || tickerOrAddress === "BTC-LN")
+        if (tickerOrAddress === "BTCLN" || tickerOrAddress === "BTC-LN" || tickerOrAddress === "LIGHTNING-BTC")
             return Token_1.BitcoinTokens.BTCLN;
         //Check if the ticker is in format <chainId>-<ticker>, i.e. SOLANA-USDC, STARKNET-WBTC
         if (tickerOrAddress.includes("-")) {

package/dist/swapper/SwapperWithSigner.d.ts

@@ -28,6 +28,7 @@ import { LightningInvoiceCreateService } from "../types/wallets/LightningInvoice
 import { Intermediary } from "../intermediaries/Intermediary";
 import { SpvFromBTCOptions } from "../swaps/spv_swaps/SpvFromBTCWrapper";
 import { SwapTypeMapping } from "../utils/SwapUtils";
+import { SwapSide } from "../enums/SwapSide";
 /**
  * Chain and signer-specific wrapper for automatic signer injection into swap methods
  * @category Core
@@ -264,14 +265,9 @@ export declare class SwapperWithSigner<T extends MultiChain, ChainIdentifier ext
      *  initiated after this blockheight
      */
     recoverSwaps(startBlockheight?: number): Promise<ISwap<T[ChainIdentifier]>[]>;
-    /**
-     * Returns the {@link Token} object for a given token
-     *
-     * @param tickerOrAddress Token to return the object for, can use multiple formats:
-     *  - a) token ticker, such as `"BTC"`, `"SOL"`, etc.
-     *  - b) token ticker prefixed with smart chain identifier, such as `"SOLANA-SOL"`, `"SOLANA-USDC"`, etc.
-     *  - c) token address
-     */
+    getToken(ticker: "BTC" | "BITCOIN-BTC"): BtcToken<false>;
+    getToken(ticker: "BTCLN" | "BTC-LN" | "LIGHTNING-BTC"): BtcToken<true>;
+    getToken(ticker: `${ChainIdentifier}-${string}`): SCToken<ChainIdentifier>;
     getToken(tickerOrAddress: string): Token<ChainIdentifier>;
     /**
      * Returns whether the SDK supports a given swap type on this chain based on currently known LPs
@@ -310,17 +306,17 @@ export declare class SwapperWithSigner<T extends MultiChain, ChainIdentifier ext
      */
     getSwapLimits<A extends Token<ChainIdentifier>, B extends Token<ChainIdentifier>>(srcToken: A, dstToken: B): {
         input: {
-            min: TokenAmount<string, A>;
-            max?: TokenAmount<string, A>;
+            min: TokenAmount<A>;
+            max?: TokenAmount<A>;
         };
         output: {
-            min: TokenAmount<string, B>;
-            max?: TokenAmount<string, B>;
+            min: TokenAmount<B>;
+            max?: TokenAmount<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>[];
+    getSwapCounterTokens(token: Token, input: SwapSide | boolean): Token<ChainIdentifier>[];
 }

package/dist/swaps/IBTCWalletSwap.d.ts

@@ -48,7 +48,7 @@ export interface IBTCWalletSwap {
      * @param wallet Sender's bitcoin wallet
      * @param feeRate Optional fee rate in sats/vB for the transaction
      */
-    estimateBitcoinFee(wallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number): Promise<TokenAmount<any, BtcToken<false>> | null>;
+    estimateBitcoinFee(wallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number): Promise<TokenAmount<BtcToken<false>> | null>;
     /**
      * Sends a swap bitcoin transaction via the passed bitcoin wallet
      *

package/dist/swaps/ISwap.js

@@ -105,6 +105,8 @@ class ISwap {
      * @internal
      */
     waitTillState(targetState, type = "eq", abortSignal) {
+        //TODO: This doesn't hold strong reference to the swap, hence if no other strong reference to the
+        // swap exists, it will just never resolve!
         return new Promise((resolve, reject) => {
             let listener;
             listener = (swap) => {

package/dist/swaps/ISwapWithGasDrop.d.ts

@@ -17,5 +17,5 @@ export interface ISwapWithGasDrop<T extends ChainType> {
      * Returns the output of the "gas drop", additional native token received by the user on
      *  the destination chain
      */
-    getGasDropOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>>;
+    getGasDropOutput(): TokenAmount<SCToken<T["ChainId"]>>;
 }