@atomiqlabs/sdk 7.0.12 → 8.0.7

package/dist/swapper/SwapperFactory.d.ts

@@ -0,0 +1,87 @@
+import { ChainType, StorageObject, IStorageManager, Messenger, ChainInitializer } from "@atomiqlabs/base";
+import { Swapper, SwapperOptions } from "./Swapper";
+import { MempoolApi } from "../bitcoin/mempool/MempoolApi";
+import { MempoolBitcoinRpc } from "../bitcoin/mempool/MempoolBitcoinRpc";
+import { BtcToken, SCToken } from "../types/Token";
+import { SwapType } from "../enums/SwapType";
+import { SwapTypeMapping } from "../utils/SwapUtils";
+import { CustomPriceFunction } from "../types/CustomPriceFunction";
+type ChainTypeDict<T extends ChainInitializer<any, any, any>> = {
+    [K in T["chainId"]]: T["chainType"];
+};
+type ToMultichain<T extends readonly ChainInitializer<any, any, any>[]> = (T extends readonly [infer First extends ChainInitializer<any, any, any>, ...infer Rest extends ChainInitializer<any, any, any>[]] ? ChainTypeDict<First> & ToMultichain<Rest> : {});
+type TokensDict<T extends ChainInitializer<any, any, any>> = {
+    [K in T["chainId"]]: TypedChainTokens<T>;
+};
+type GetAllTokens<T extends readonly ChainInitializer<any, any, any>[]> = (T extends readonly [infer First extends ChainInitializer<any, any, any>, ...infer Rest extends ChainInitializer<any, any, any>[]] ? TokensDict<First> & GetAllTokens<Rest> : unknown);
+type TokenResolverDict<T extends ChainInitializer<any, any, any>> = {
+    [K in T["chainId"]]: TypedChainTokenResolver<T>;
+};
+type OptionsDict<T extends ChainInitializer<any, any, any>> = {
+    [K in T["chainId"]]: T["options"];
+};
+type GetAllOptions<T extends readonly ChainInitializer<any, any, any>[]> = (T extends readonly [infer First extends ChainInitializer<any, any, any>, ...infer Rest extends ChainInitializer<any, any, any>[]] ? OptionsDict<First> & GetAllOptions<Rest> : unknown);
+/**
+ * Configuration options for creating a typed Swapper instance
+ * @category Core
+ */
+export type TypedSwapperOptions<T extends readonly ChainInitializer<any, any, any>[]> = {
+    chains: GetAllOptions<T>;
+    chainStorageCtor?: <T extends StorageObject>(name: string) => IStorageManager<T>;
+    pricingFeeDifferencePPM?: bigint;
+    getPriceFn?: CustomPriceFunction;
+    mempoolApi?: MempoolApi | MempoolBitcoinRpc | string | string[];
+    messenger?: Messenger;
+} & SwapperOptions;
+/**
+ * Token resolver for a specific chain
+ * @category Core
+ */
+export type TypedChainTokenResolver<T extends ChainInitializer<any, any, any>> = {
+    getToken: (address: string) => SCToken<T["chainId"]>;
+};
+/**
+ * Token resolvers for all chains
+ * @category Core
+ */
+export type TypedTokenResolvers<T extends readonly ChainInitializer<any, any, any>[]> = (T extends readonly [infer First extends ChainInitializer<any, any, any>, ...infer Rest extends ChainInitializer<any, any, any>[]] ? TokenResolverDict<First> & TypedTokenResolvers<Rest> : unknown);
+/**
+ * Token definitions for a specific chain
+ * @category Core
+ */
+export type TypedChainTokens<T extends ChainInitializer<any, any, any>> = {
+    [val in keyof T["tokens"]]: SCToken<T["chainId"]>;
+};
+/**
+ * All tokens including Bitcoin tokens
+ * @category Core
+ */
+export type TypedTokens<T extends readonly ChainInitializer<any, ChainType, any>[]> = GetAllTokens<T> & {
+    BITCOIN: {
+        BTC: BtcToken<false>;
+        BTCLN: BtcToken<true>;
+    };
+};
+/**
+ * Type alias for a Swapper instance with typed chain support
+ * @category Core
+ */
+export type TypedSwapper<T extends readonly ChainInitializer<any, ChainType, any>[]> = Swapper<ToMultichain<T>>;
+/**
+ * Type alias for a specific swap type on a chain
+ * @category Core
+ */
+export type TypedSwap<T extends ChainInitializer<any, ChainType, any>, S extends SwapType> = SwapTypeMapping<T["chainType"]>[S];
+/**
+ * Factory class for creating and initializing Swapper instances with typed chain support
+ * @category Core
+ */
+export declare class SwapperFactory<T extends readonly ChainInitializer<any, ChainType, any>[]> {
+    readonly initializers: T;
+    Tokens: TypedTokens<T>;
+    TokenResolver: TypedTokenResolvers<T>;
+    constructor(initializers: T);
+    newSwapper(options: TypedSwapperOptions<T>): TypedSwapper<T>;
+    newSwapperInitialized(options: TypedSwapperOptions<T>): Promise<TypedSwapper<T>>;
+}
+export {};

package/dist/{SwapperFactory.js → swapper/SwapperFactory.js}

@@ -2,10 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwapperFactory = void 0;
 const base_1 = require("@atomiqlabs/base");
-const sdk_lib_1 = require("@atomiqlabs/sdk-lib");
-const SmartChainAssets_1 = require("./SmartChainAssets");
-const LocalStorageManager_1 = require("./storage/LocalStorageManager");
+const SmartChainAssets_1 = require("../SmartChainAssets");
 const messenger_nostr_1 = require("@atomiqlabs/messenger-nostr");
+const Swapper_1 = require("./Swapper");
+const MempoolBitcoinRpc_1 = require("../bitcoin/mempool/MempoolBitcoinRpc");
+const CustomPriceProvider_1 = require("../prices/providers/CustomPriceProvider");
+const Token_1 = require("../types/Token");
+const RedundantSwapPrice_1 = require("../prices/RedundantSwapPrice");
+const LocalStorageManager_1 = require("../storage-browser/LocalStorageManager");
+const SingleSwapPrice_1 = require("../prices/SingleSwapPrice");
 const registries = {
     [base_1.BitcoinNetwork.MAINNET]: "https://api.github.com/repos/adambor/SolLightning-registry/contents/registry-mainnet.json?ref=main",
     [base_1.BitcoinNetwork.TESTNET]: "https://api.github.com/repos/adambor/SolLightning-registry/contents/registry.json?ref=main",
@@ -41,20 +46,24 @@ const mempoolUrls = {
 const nostrUrls = [
     "wss://relay.damus.io", "wss://nostr.einundzwanzig.space", "wss://relay01.lnfi.network/", "wss://relay.puresignal.news/", "wss://relay.fountain.fm/", "wss://sendit.nosflare.com/"
 ];
+/**
+ * Factory class for creating and initializing Swapper instances with typed chain support
+ * @category Core
+ */
 class SwapperFactory {
     constructor(initializers) {
         this.initializers = initializers;
         this.Tokens = {
-            BITCOIN: sdk_lib_1.BitcoinTokens
+            BITCOIN: Token_1.BitcoinTokens
         };
         this.TokenResolver = {};
         this.initializers = initializers;
         initializers.forEach(initializer => {
             const addressMap = {};
-            this.Tokens[initializer.chainId] = {};
+            const tokens = (this.Tokens[initializer.chainId] = {});
             for (let ticker in initializer.tokens) {
                 const assetData = initializer.tokens[ticker];
-                this.Tokens[initializer.chainId][ticker] = addressMap[assetData.address] = {
+                tokens[ticker] = addressMap[assetData.address] = {
                     chain: "SC",
                     chainId: initializer.chainId,
                     address: assetData.address,
@@ -70,13 +79,21 @@ class SwapperFactory {
         });
     }
     newSwapper(options) {
-        options.bitcoinNetwork ?? (options.bitcoinNetwork = base_1.BitcoinNetwork.MAINNET);
-        options.storagePrefix ?? (options.storagePrefix = "atomiqsdk-" + options.bitcoinNetwork + "-");
-        options.messenger ?? (options.messenger = new messenger_nostr_1.NostrMessenger(options.bitcoinNetwork, nostrUrls));
-        options.defaultTrustedIntermediaryUrl ?? (options.defaultTrustedIntermediaryUrl = trustedIntermediaries[options.bitcoinNetwork]);
-        options.registryUrl ?? (options.registryUrl = registries[options.bitcoinNetwork]);
-        const mempoolApi = options.mempoolApi ?? new sdk_lib_1.MempoolBitcoinRpc(mempoolUrls[options.bitcoinNetwork]);
-        const bitcoinRpc = mempoolApi instanceof sdk_lib_1.MempoolBitcoinRpc ? mempoolApi : new sdk_lib_1.MempoolBitcoinRpc(mempoolApi);
+        options.bitcoinNetwork ??= base_1.BitcoinNetwork.MAINNET;
+        options.storagePrefix ??= "atomiqsdk-" + options.bitcoinNetwork + "-";
+        options.messenger ??= new messenger_nostr_1.NostrMessenger(options.bitcoinNetwork, nostrUrls);
+        options.defaultTrustedIntermediaryUrl ??= trustedIntermediaries[options.bitcoinNetwork];
+        options.registryUrl ??= registries[options.bitcoinNetwork];
+        let bitcoinRpc;
+        if (options.mempoolApi != null) {
+            bitcoinRpc = options.mempoolApi instanceof MempoolBitcoinRpc_1.MempoolBitcoinRpc ? options.mempoolApi : new MempoolBitcoinRpc_1.MempoolBitcoinRpc(options.mempoolApi);
+        }
+        else {
+            const urls = mempoolUrls[options.bitcoinNetwork];
+            if (urls == null)
+                throw new Error(`No pre-configured urls for ${base_1.BitcoinNetwork[options.bitcoinNetwork]} network were found, please explicitly pass mempoolApi parameter!`);
+            bitcoinRpc = new MempoolBitcoinRpc_1.MempoolBitcoinRpc(urls);
+        }
         const pricingAssets = [];
         Object.keys(SmartChainAssets_1.SmartChainAssets).forEach((ticker) => {
             const chains = {};
@@ -92,22 +109,23 @@ class SwapperFactory {
                 name: assetData.name
             });
         });
-        options.chainStorageCtor ?? (options.chainStorageCtor = (name) => new LocalStorageManager_1.LocalStorageManager(name));
+        options.chainStorageCtor ??= (name) => new LocalStorageManager_1.LocalStorageManager(name);
         const chains = {};
         for (let { initializer, chainId } of this.initializers) {
-            if (options.chains[chainId] == null)
+            const chainOptions = options.chains[chainId];
+            if (chainOptions == null)
                 continue;
-            chains[chainId] = initializer(options.chains[chainId], bitcoinRpc, options.bitcoinNetwork, options.chainStorageCtor);
+            chains[chainId] = initializer(chainOptions, bitcoinRpc, options.bitcoinNetwork, options.chainStorageCtor);
         }
         const swapPricing = options.getPriceFn != null ?
-            new sdk_lib_1.SingleSwapPrice(options.pricingFeeDifferencePPM ?? 10000n, new sdk_lib_1.CustomPriceProvider(pricingAssets.map(val => {
+            new SingleSwapPrice_1.SingleSwapPrice(options.pricingFeeDifferencePPM ?? 10000n, new CustomPriceProvider_1.CustomPriceProvider(pricingAssets.map(val => {
                 return {
                     coinId: val.ticker,
                     chains: val.chains
                 };
             }), options.getPriceFn)) :
-            sdk_lib_1.RedundantSwapPrice.createFromTokenMap(options.pricingFeeDifferencePPM ?? 10000n, pricingAssets);
-        return new sdk_lib_1.Swapper(bitcoinRpc, chains, swapPricing, pricingAssets, options.messenger, options);
+            RedundantSwapPrice_1.RedundantSwapPrice.createFromTokenMap(options.pricingFeeDifferencePPM ?? 10000n, pricingAssets);
+        return new Swapper_1.Swapper(bitcoinRpc, chains, swapPricing, pricingAssets, options.messenger, options);
     }
     async newSwapperInitialized(options) {
         const swapper = this.newSwapper(options);

package/dist/swapper/SwapperUtils.d.ts

@@ -0,0 +1,153 @@
+import { Transaction } from "@scure/btc-signer";
+import { BTC_NETWORK } from "@scure/btc-signer/utils";
+import { SwapType } from "../enums/SwapType";
+import { ChainIds, MultiChain, Swapper } from "./Swapper";
+import { IBitcoinWallet } from "../bitcoin/wallet/IBitcoinWallet";
+import { MinimalBitcoinWalletInterface } from "../bitcoin/wallet/MinimalBitcoinWalletInterface";
+import { TokenAmount } from "../types/TokenAmount";
+import { SCToken } from "../types/Token";
+import { LNURLWithdraw } from "../types/lnurl/LNURLWithdraw";
+import { LNURLPay } from "../types/lnurl/LNURLPay";
+/**
+ * Utility class providing helper methods for swap operations
+ * @category Core
+ */
+export declare class SwapperUtils<T extends MultiChain> {
+    readonly bitcoinNetwork: BTC_NETWORK;
+    private readonly root;
+    constructor(root: Swapper<T>);
+    isValidSmartChainAddress(address: string, chainId?: ChainIds<T>): boolean;
+    /**
+     * Returns true if string is a valid BOLT11 bitcoin lightning invoice
+     *
+     * @param lnpr
+     */
+    isLightningInvoice(lnpr: string): boolean;
+    /**
+     * Returns true if string is a valid bitcoin address
+     *
+     * @param addr
+     */
+    isValidBitcoinAddress(addr: string): boolean;
+    /**
+     * Returns true if string is a valid BOLT11 bitcoin lightning invoice WITH AMOUNT
+     *
+     * @param lnpr
+     */
+    isValidLightningInvoice(lnpr: string): boolean;
+    /**
+     * Returns true if string is a valid LNURL (no checking on type is performed)
+     *
+     * @param lnurl
+     */
+    isValidLNURL(lnurl: string): boolean;
+    /**
+     * Returns type and data about an LNURL
+     *
+     * @param lnurl
+     * @param shouldRetry
+     */
+    getLNURLTypeAndData(lnurl: string, shouldRetry?: boolean): Promise<LNURLPay | LNURLWithdraw | null>;
+    /**
+     * Returns satoshi value of BOLT11 bitcoin lightning invoice WITH AMOUNT, returns null otherwise
+     *
+     * @param lnpr
+     */
+    getLightningInvoiceValue(lnpr: string): bigint | null;
+    private parseBitcoinAddress;
+    private parseLNURLSync;
+    private parseLNURL;
+    private parseLightningInvoice;
+    private parseSmartchainAddress;
+    /**
+     * General parser for bitcoin addresses, LNURLs, lightning invoices, smart chain addresses, also fetches LNURL data
+     *  (hence returns Promise)
+     *
+     * @param addressString Address to parse
+     * @throws {Error} Error in address parsing
+     * @returns Address data or null if address doesn't conform to any known format
+     */
+    parseAddress(addressString: string): Promise<{
+        address: string;
+        type: "BITCOIN" | "LIGHTNING" | "LNURL" | ChainIds<T>;
+        swapType: SwapType.TO_BTC | SwapType.TO_BTCLN | SwapType.SPV_VAULT_FROM_BTC | SwapType.FROM_BTCLN | null;
+        lnurl?: LNURLPay | LNURLWithdraw;
+        min?: TokenAmount;
+        max?: TokenAmount;
+        amount?: TokenAmount;
+    } | null>;
+    /**
+     * Synchronous general parser for bitcoin addresses, LNURLs, lightning invoices, smart chain addresses, doesn't fetch
+     *  LNURL data, reports swapType: null instead to prevent returning a Promise
+     *
+     * @param addressString Address to parse
+     * @throws {Error} Error in address parsing
+     * @returns Address data or null if address doesn't conform to any known format
+     */
+    parseAddressSync(addressString: string): {
+        address: string;
+        type: "BITCOIN" | "LIGHTNING" | "LNURL" | ChainIds<T>;
+        swapType: SwapType.TO_BTC | SwapType.TO_BTCLN | SwapType.SPV_VAULT_FROM_BTC | null;
+        min?: TokenAmount;
+        max?: TokenAmount;
+        amount?: TokenAmount;
+    } | null;
+    /**
+     * Returns a random PSBT that can be used for fee estimation, the last output (the LP output) is omitted
+     *  to allow for coinselection algorithm to determine maximum sendable amount there
+     *
+     * @param chainIdentifier
+     * @param includeGasToken   Whether to return the PSBT also with the gas token amount (increases the vSize by 8)
+     */
+    getRandomSpvVaultPsbt<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, includeGasToken?: boolean): Transaction;
+    /**
+     * Returns the spendable balance of a bitcoin wallet
+     *
+     * @param wallet
+     * @param targetChain
+     * @param options Additional options
+     */
+    getBitcoinSpendableBalance(wallet: string | IBitcoinWallet | MinimalBitcoinWalletInterface, targetChain?: ChainIds<T>, options?: {
+        gasDrop?: boolean;
+        feeRate?: number;
+        minFeeRate?: number;
+    }): Promise<{
+        balance: TokenAmount;
+        feeRate: number;
+    }>;
+    /**
+     * Returns the maximum spendable balance of the wallet, deducting the fee needed to initiate a swap for native balances
+     */
+    getSpendableBalance<ChainIdentifier extends ChainIds<T>>(wallet: string | T[ChainIdentifier]["Signer"] | T[ChainIdentifier]["NativeSigner"], token: SCToken<ChainIdentifier>, options?: {
+        feeMultiplier?: number;
+        feeRate?: any;
+    }): Promise<TokenAmount>;
+    /**
+     * Returns the address of the native currency of the chain
+     */
+    getNativeToken<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier): SCToken<ChainIdentifier>;
+    /**
+     * Returns a random signer for a given smart chain
+     *
+     * @param chainIdentifier
+     */
+    randomSigner<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier): T[ChainIdentifier]["Signer"];
+    /**
+     * Returns a random address for a given smart chain
+     *
+     * @param chainIdentifier
+     */
+    randomAddress<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier): string;
+    /**
+     * Signs and broadcasts the supplied smart chain transaction
+     */
+    sendAndConfirm<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, signer: T[ChainIdentifier]["NativeSigner"] | T[ChainIdentifier]["Signer"], txs: T[ChainIdentifier]["TX"][], abortSignal?: AbortSignal, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    /**
+     * Broadcasts already signed smart chain transactions
+     */
+    sendSignedAndConfirm<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, txs: T[ChainIdentifier]["SignedTXType"][], abortSignal?: AbortSignal, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    serializeUnsignedTransaction<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, tx: T[ChainIdentifier]["TX"]): Promise<string>;
+    deserializeUnsignedTransaction<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, tx: string): Promise<T[ChainIdentifier]["TX"]>;
+    serializeSignedTransaction<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, tx: T[ChainIdentifier]["SignedTXType"]): Promise<string>;
+    deserializeSignedTransaction<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, tx: string): Promise<T[ChainIdentifier]["SignedTXType"]>;
+}