@atomiqlabs/sdk 7.0.12 → 8.0.8

package/src/{SwapperFactory.ts → swapper/SwapperFactory.ts}

@@ -1,54 +1,42 @@
 import {
     ChainData,
     BitcoinNetwork,
-    BitcoinRpc,
-    BaseTokenType,
     ChainType,
     StorageObject,
-    IStorageManager, Messenger
+    IStorageManager, Messenger, ChainInitializer
 } from "@atomiqlabs/base";
-import {
-    BitcoinTokens,
-    BtcToken, CustomPriceFunction, CustomPriceProvider,
-    MempoolApi,
-    MempoolBitcoinRpc, RedundantSwapPrice,
-    RedundantSwapPriceAssets, SCToken, SingleSwapPrice, Swapper,
-    SwapperOptions
-} from "@atomiqlabs/sdk-lib";
-import {SmartChainAssets} from "./SmartChainAssets";
-import {LocalStorageManager} from "./storage/LocalStorageManager";
+import {SmartChainAssets, SmartChainAssetTickers} from "../SmartChainAssets";
 import {NostrMessenger} from "@atomiqlabs/messenger-nostr";
-
-type ChainInitializer<O, C extends ChainType, T extends BaseTokenType> = {
-    chainId: ChainType["ChainId"],
-    chainType: ChainType,
-    initializer: (
-        options: O,
-        bitcoinRelay: BitcoinRpc<any>,
-        network: BitcoinNetwork,
-        storageCtor: <T extends StorageObject>(name: string) => IStorageManager<T>
-    ) => ChainData<C>,
-    tokens: T,
-    options: O
-}
+import {Swapper, SwapperOptions} from "./Swapper";
+import {MempoolApi} from "../bitcoin/mempool/MempoolApi";
+import {MempoolBitcoinRpc} from "../bitcoin/mempool/MempoolBitcoinRpc";
+import {CustomPriceProvider} from "../prices/providers/CustomPriceProvider";
+import {BitcoinTokens, BtcToken, SCToken} from "../types/Token";
+import {SwapType} from "../enums/SwapType";
+import {SwapTypeMapping} from "../utils/SwapUtils";
+import {RedundantSwapPrice, RedundantSwapPriceAssets} from "../prices/RedundantSwapPrice";
+import {LocalStorageManager} from "../storage-browser/LocalStorageManager";
+import {SingleSwapPrice} from "../prices/SingleSwapPrice";
+import {CustomPriceFunction} from "../types/CustomPriceFunction";
+
+//Helper types
+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"]]: {
-        [val in keyof T["tokens"]]: SCToken<K>
-    }
+    [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);
 
-export type TokenResolverDict<T extends ChainInitializer<any, any, any>> = {[K in T["chainId"]]: {
-    getToken: (address: string) => SCToken<K>
-}};
-type GetAllTokenResolvers<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> & GetAllTokenResolvers<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>[]> =
@@ -56,34 +44,83 @@ type GetAllOptions<T extends readonly ChainInitializer<any, any, any>[]> =
         ? OptionsDict<First> & GetAllOptions<Rest>
         : unknown);
 
-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>
-        : {});
-
-export type MultichainSwapperOptions<T extends readonly ChainInitializer<any, any, any>[]> = SwapperOptions & {
-    chains: GetAllOptions<T>
-} & {
+//Exported types
+/**
+ * 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,
-    getPriceFn?: CustomPriceFunction
+} & 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"]>
 };
 
-const registries = {
+/**
+ * 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];
+
+const registries: {[key in BitcoinNetwork]?: string} = {
     [BitcoinNetwork.MAINNET]: "https://api.github.com/repos/adambor/SolLightning-registry/contents/registry-mainnet.json?ref=main",
     [BitcoinNetwork.TESTNET]: "https://api.github.com/repos/adambor/SolLightning-registry/contents/registry.json?ref=main",
     [BitcoinNetwork.TESTNET4]: "https://api.github.com/repos/adambor/SolLightning-registry/contents/registry-testnet4.json?ref=main"
 }
 
-const trustedIntermediaries = {
+const trustedIntermediaries: {[key in BitcoinNetwork]?: string} = {
     [BitcoinNetwork.MAINNET]: "https://node3.gethopa.com:34100",
     [BitcoinNetwork.TESTNET]: "https://node3.gethopa.com:24100"
 }
 
-const mempoolUrls = {
+const mempoolUrls: {[key in BitcoinNetwork]?: string[]} = {
     [BitcoinNetwork.MAINNET]: [
         "https://mempool.space/api/",
         // "https://mempool.holdings/api/",
@@ -111,55 +148,58 @@ const nostrUrls: string[] = [
     "wss://relay.damus.io", "wss://nostr.einundzwanzig.space", "wss://relay01.lnfi.network/", "wss://relay.puresignal.news/", "wss://relay.fountain.fm/", "wss://sendit.nosflare.com/"
 ];
 
-export class SwapperFactory<T extends readonly ChainInitializer<any, any, any>[]> {
+/**
+ * Factory class for creating and initializing Swapper instances with typed chain support
+ * @category Core
+ */
+export class SwapperFactory<T extends readonly ChainInitializer<any, ChainType, any>[]> {
 
-    Tokens: GetAllTokens<T> & {
-        BITCOIN: {
-            BTC: BtcToken<false>,
-            BTCLN: BtcToken<true>
-        }
-    } = {
+    Tokens: TypedTokens<T> = {
         BITCOIN: BitcoinTokens
     } as any;
-    TokenResolver: GetAllTokenResolvers<T> = {} as any;
+    TokenResolver: TypedTokenResolvers<T> = {} as any;
 
     constructor(readonly initializers: T) {
         this.initializers = initializers;
         initializers.forEach(initializer => {
             const addressMap: {[tokenAddress: string]: SCToken} = {};
 
-            this.Tokens[initializer.chainId] = {} as any;
+            const tokens = (this.Tokens[initializer.chainId as keyof GetAllTokens<T>] = {} as any);
 
             for(let ticker in initializer.tokens) {
                 const assetData = initializer.tokens[ticker] as any;
-                this.Tokens[initializer.chainId][ticker] = addressMap[assetData.address] = {
+                tokens[ticker] = addressMap[assetData.address] = {
                     chain: "SC",
                     chainId: initializer.chainId,
                     address: assetData.address,
-                    name: SmartChainAssets[ticker]?.name ?? ticker,
+                    name: SmartChainAssets[ticker as SmartChainAssetTickers]?.name ?? ticker,
                     decimals: assetData.decimals,
                     displayDecimals: assetData.displayDecimals,
                     ticker
                 } as any;
             }
 
-            this.TokenResolver[initializer.chainId] = {
+            this.TokenResolver[initializer.chainId as keyof TypedTokenResolvers<T>] = {
                 getToken: (address: string) => addressMap[address]
             } as any;
         });
     }
 
-    newSwapper(options: MultichainSwapperOptions<T>) {
-        options.bitcoinNetwork ??= BitcoinNetwork.MAINNET as any;
+    newSwapper(options: TypedSwapperOptions<T>): TypedSwapper<T> {
+        options.bitcoinNetwork ??= BitcoinNetwork.MAINNET;
         options.storagePrefix ??= "atomiqsdk-"+options.bitcoinNetwork+"-";
         options.messenger ??= new NostrMessenger(options.bitcoinNetwork, nostrUrls);
-
         options.defaultTrustedIntermediaryUrl ??= trustedIntermediaries[options.bitcoinNetwork];
-
         options.registryUrl ??= registries[options.bitcoinNetwork];
 
-        const mempoolApi = options.mempoolApi ?? new MempoolBitcoinRpc(mempoolUrls[options.bitcoinNetwork]);
-        const bitcoinRpc = mempoolApi instanceof MempoolBitcoinRpc ? mempoolApi : new MempoolBitcoinRpc(mempoolApi);
+        let bitcoinRpc: MempoolBitcoinRpc;
+        if(options.mempoolApi!=null) {
+            bitcoinRpc = options.mempoolApi instanceof MempoolBitcoinRpc ? options.mempoolApi : new MempoolBitcoinRpc(options.mempoolApi);
+        } else {
+            const urls = mempoolUrls[options.bitcoinNetwork];
+            if(urls==null) throw new Error(`No pre-configured urls for ${BitcoinNetwork[options.bitcoinNetwork]} network were found, please explicitly pass mempoolApi parameter!`);
+            bitcoinRpc = new MempoolBitcoinRpc(urls);
+        }
 
         const pricingAssets: (RedundantSwapPriceAssets<ToMultichain<T>>[number] & {ticker: string, name: string})[] = [];
         Object.keys(SmartChainAssets).forEach((ticker) => {
@@ -167,7 +207,7 @@ export class SwapperFactory<T extends readonly ChainInitializer<any, any, any>[]
             for(let {tokens, chainId} of this.initializers) {
                 if(tokens[ticker]!=null) chains[chainId] = tokens[ticker];
             }
-            const assetData = SmartChainAssets[ticker];
+            const assetData = SmartChainAssets[ticker as SmartChainAssetTickers];
             pricingAssets.push({
                 ...assetData.pricing,
                 chains,
@@ -176,12 +216,13 @@ export class SwapperFactory<T extends readonly ChainInitializer<any, any, any>[]
             })
         });
 
-        options.chainStorageCtor ??= (name: string) => new LocalStorageManager(name);
+        options.chainStorageCtor ??= <T extends StorageObject>(name: string) => new LocalStorageManager<T>(name);
 
         const chains: {[key in T[number]["chainId"]]: ChainData<any>} = {} as any;
         for(let {initializer, chainId} of this.initializers) {
-            if(options.chains[chainId]==null) continue;
-            chains[chainId] = initializer(options.chains[chainId], bitcoinRpc, options.bitcoinNetwork, options.chainStorageCtor) as any;
+            const chainOptions = options.chains[chainId as keyof GetAllOptions<T>];
+            if(chainOptions==null) continue;
+            chains[chainId as T[number]["chainId"]] = initializer(chainOptions, bitcoinRpc, options.bitcoinNetwork, options.chainStorageCtor) as any;
         }
 
         const swapPricing = options.getPriceFn!=null ?
@@ -203,7 +244,7 @@ export class SwapperFactory<T extends readonly ChainInitializer<any, any, any>[]
         );
     }
 
-    async newSwapperInitialized(options: MultichainSwapperOptions<T>) {
+    async newSwapperInitialized(options: TypedSwapperOptions<T>): Promise<TypedSwapper<T>> {
         const swapper = this.newSwapper(options);
         await swapper.init();
         return swapper;