@cryptorubic/web3 0.0.35 → 0.0.37-alpha-1212.0

package/src/lib/adapter/adapters/utils/errors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseError = parseError;
+const rubic_sdk_error_1 = require("../../../errors/rubic-sdk.error");
+function parseError(err, defaultMessage) {
+    if (err instanceof rubic_sdk_error_1.RubicSdkError) {
+        return err;
+    }
+    return new rubic_sdk_error_1.RubicSdkError(err?.message || defaultMessage || 'Unknown error');
+}

package/src/lib/adapter/adapters/utils/options.d.ts

@@ -0,0 +1,10 @@
+import BigNumber from 'bignumber.js';
+import { EvmTransactionOptions } from '../adapter-evm/models/evm-send-tx-params';
+import { SwapTransactionOptions } from '../models/old-features-models/swap-transaction-options';
+import { EIP1559ViemGas, SingleViemGasPrice } from '../models/evm-web3-public-models/gas-price-viem';
+import { EIP1559Gas, SingleGasPrice } from '../models/evm-web3-public-models/gas-price';
+export declare function stringifyAmount(amount: number | string | BigNumber, multiplier?: number): string;
+export declare function combineOptions<T extends object>(options: Partial<T> | undefined, defaultOptions: T): T;
+export declare function deadlineMinutesTimestamp(deadlineMinutes: number): number;
+export declare function getGasOptions(options: SwapTransactionOptions | EvmTransactionOptions): EIP1559Gas | SingleGasPrice | Record<never, never>;
+export declare function getViemGasOptions(options: SwapTransactionOptions | EvmTransactionOptions): EIP1559ViemGas | SingleViemGasPrice | Record<never, never>;

package/src/lib/adapter/adapters/utils/options.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyAmount = stringifyAmount;
+exports.combineOptions = combineOptions;
+exports.deadlineMinutesTimestamp = deadlineMinutesTimestamp;
+exports.getGasOptions = getGasOptions;
+exports.getViemGasOptions = getViemGasOptions;
+const bignumber_js_1 = require("bignumber.js");
+const rubic_sdk_error_1 = require("../../../errors/rubic-sdk.error");
+function stringifyAmount(amount, multiplier = 1) {
+    const bnAmount = new bignumber_js_1.default(amount);
+    if (!bnAmount.isInteger()) {
+        throw new rubic_sdk_error_1.RubicSdkError(`Value ${amount} is not integer`);
+    }
+    return bnAmount.multipliedBy(multiplier).toFixed(0);
+}
+function combineOptions(options, defaultOptions) {
+    return {
+        ...defaultOptions,
+        ...options
+    };
+}
+function deadlineMinutesTimestamp(deadlineMinutes) {
+    return Math.floor(Date.now() / 1000 + 60 * deadlineMinutes);
+}
+function getGasOptions(options) {
+    const { gasPriceOptions } = options;
+    if (!gasPriceOptions)
+        return {};
+    if ('gasPrice' in gasPriceOptions && gasPriceOptions.gasPrice) {
+        return {
+            gasPrice: stringifyAmount(gasPriceOptions.gasPrice)
+        };
+    }
+    if ('maxPriorityFeePerGas' in gasPriceOptions && gasPriceOptions.maxPriorityFeePerGas && gasPriceOptions.maxFeePerGas) {
+        return {
+            maxPriorityFeePerGas: stringifyAmount(gasPriceOptions.maxPriorityFeePerGas),
+            maxFeePerGas: stringifyAmount(gasPriceOptions.maxFeePerGas)
+        };
+    }
+    return {};
+}
+function getViemGasOptions(options) {
+    const { gasPriceOptions } = options;
+    if (!gasPriceOptions)
+        return {};
+    if ('gasPrice' in gasPriceOptions && gasPriceOptions.gasPrice) {
+        return {
+            gasPrice: BigInt(gasPriceOptions.gasPrice)
+        };
+    }
+    if ('maxPriorityFeePerGas' in gasPriceOptions && gasPriceOptions.maxPriorityFeePerGas && gasPriceOptions.maxFeePerGas) {
+        return {
+            maxPriorityFeePerGas: BigInt(gasPriceOptions.maxPriorityFeePerGas),
+            maxFeePerGas: BigInt(gasPriceOptions.maxFeePerGas)
+        };
+    }
+    return {};
+}

package/src/lib/adapter/adapters/utils/timeout.d.ts

@@ -0,0 +1 @@
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, timeoutText?: string): Promise<T>;

package/src/lib/adapter/adapters/utils/timeout.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTimeout = withTimeout;
+function withTimeout(promise, ms, timeoutText) {
+    let timeoutId = null;
+    const rejectOnDeadline = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(timeoutText);
+        }, ms);
+    });
+    return Promise.race([rejectOnDeadline, promise]).finally(() => {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+    });
+}

package/src/lib/adapter/adapters/utils/waitFor.d.ts

@@ -0,0 +1 @@
+export declare function waitFor(milliseconds: number): Promise<void>;

package/src/lib/adapter/adapters/utils/waitFor.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitFor = waitFor;
+async function waitFor(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

package/src/lib/adapter/blockchain-adapter-factory.service.d.ts

@@ -1,25 +1,33 @@
-import { SolanaAdapter } from './adapters/solana-adapter';
-import { TronAdapter } from './adapters/tron-adapter';
-import { AbstractAdapter } from './adapters/abstract-adapter';
-import { WalletProvider } from "./constants/models/wallet-provider";
-import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, HttpClient, TonBlockchainName } from "@cryptorubic/core";
-import { TonAdapter } from "./adapters/ton-adapter";
-import { TonAdapterConfig } from "./adapters/models/ton-adapter-config";
-import { EvmAdapter } from "./adapters/evm-adapter";
+import { AbstractAdapter } from './adapters/common/abstract-adapter';
+import { WalletProviderCore } from './constants/models/wallet-provider';
+import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, TonBlockchainName, BitcoinBlockchainName, SuiBlockchainName, StellarBlockchainName } from '@cryptorubic/core';
+import { TonAdapter } from './adapters/adapter-ton/ton-adapter';
+import { EvmAdapter } from './adapters/adapter-evm/evm-adapter';
+import { BitcoinAdapter } from './adapters/adapter-bitcoin/bitcoin-adapter';
+import { SolanaAdapter } from './adapters/adapter-solana/solana-adapter';
+import { TronAdapter } from './adapters/adapter-tron/tron-adapter';
+import { SuiAdapter } from './adapters/adapter-sui/sui-adapter';
+import { AdapterFactoryParams } from './models/create-factory-params';
+import { StellarAdapter } from './adapters/adapter-stellar/stellar-adapter';
 export declare class BlockchainAdapterFactoryService {
     private readonly rpcList;
+    private readonly httpClient;
     private readonly createLogger?;
-    private readonly httpClient?;
     private readonly tonParams?;
+    private readonly clientParams?;
     readonly adapterStore: Partial<Record<BlockchainName, AbstractAdapter<unknown, unknown, BlockchainName>>>;
     protected readonly logger?: ICustomLogger;
     private constructor();
-    static createFactory(rpcList: Partial<Record<EvmBlockchainName, string[]>>, httpClient?: HttpClient, tonParams?: TonAdapterConfig, createLogger?: (label: string) => ICustomLogger): Promise<BlockchainAdapterFactoryService>;
+    hasAdapterFor(blockchain: BlockchainName): boolean;
+    static createFactory(params: AdapterFactoryParams): Promise<BlockchainAdapterFactoryService>;
     getAdapter(blockchain: SolanaBlockchainName): SolanaAdapter;
     getAdapter(blockchain: EvmBlockchainName): EvmAdapter;
     getAdapter(blockchain: TronBlockchainName): TronAdapter;
     getAdapter(blockchain: TonBlockchainName): TonAdapter;
+    getAdapter(blockchain: BitcoinBlockchainName): BitcoinAdapter;
+    getAdapter(blockchain: SuiBlockchainName): SuiAdapter;
+    getAdapter(blockchain: StellarBlockchainName): StellarAdapter;
     private createStorage;
     private createAdapter;
-    connectWallet(walletProvider: WalletProvider): void;
+    connectWallet(blockchain: BlockchainName, wallet: WalletProviderCore): void;
 }

package/src/lib/adapter/blockchain-adapter-factory.service.js

@@ -2,29 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockchainAdapterFactoryService = void 0;
 const viem_blockchain_mapping_1 = require("./constants/viem-blockchain-mapping");
-const solana_adapter_1 = require("./adapters/solana-adapter");
-const tron_adapter_1 = require("./adapters/tron-adapter");
-const viem_1 = require("viem");
 const core_1 = require("@cryptorubic/core");
-const ton_adapter_1 = require("./adapters/ton-adapter");
-const evm_adapter_1 = require("./adapters/evm-adapter");
+const ton_adapter_1 = require("./adapters/adapter-ton/ton-adapter");
+const evm_adapter_1 = require("./adapters/adapter-evm/evm-adapter");
+const bitcoin_adapter_1 = require("./adapters/adapter-bitcoin/bitcoin-adapter");
+const solana_adapter_1 = require("./adapters/adapter-solana/solana-adapter");
+const tron_adapter_1 = require("./adapters/adapter-tron/tron-adapter");
+const sui_adapter_1 = require("./adapters/adapter-sui/sui-adapter");
+const stellar_adapter_1 = require("./adapters/adapter-stellar/stellar-adapter");
 class BlockchainAdapterFactoryService {
-    constructor(rpcList, createLogger, httpClient, tonParams) {
+    constructor(rpcList, httpClient, createLogger, tonParams, clientParams) {
         this.rpcList = rpcList;
-        this.createLogger = createLogger;
         this.httpClient = httpClient;
+        this.createLogger = createLogger;
         this.tonParams = tonParams;
+        this.clientParams = clientParams;
         this.adapterStore = {};
         this.adapterStore = this.createStorage();
         if (this.createLogger) {
             this.logger = this.createLogger('BlockchainAdapterFactory');
         }
     }
-    static async createFactory(rpcList, httpClient, tonParams, createLogger) {
+    hasAdapterFor(blockchain) {
+        const adapter = this.adapterStore?.[blockchain];
+        return !!adapter;
+    }
+    static async createFactory(params) {
         // @TODO Add default logger
-        const loggerFn = createLogger || undefined;
-        const resolvedHttpClient = httpClient ?? await Promise.resolve().then(() => require('axios'));
-        return new this(rpcList, createLogger, resolvedHttpClient, tonParams);
+        const loggerFn = params.createLogger || undefined;
+        const resolvedHttpClient = params.httpClient ?? (await Promise.resolve().then(() => require('axios')));
+        return new this(params.rpcList, resolvedHttpClient, params.createLogger, params.tonParams, params.clientParams);
     }
     getAdapter(blockchain) {
         const adapter = this.adapterStore?.[blockchain];
@@ -35,81 +42,75 @@ class BlockchainAdapterFactoryService {
         return adapter;
     }
     createStorage() {
-        const adapters = Object.entries(this.rpcList)
-            .map(([blockchain, rpcs]) => {
+        const adapters = Object.entries(this.rpcList).map(([blockchain, rpcs]) => {
             const adapter = this.createAdapter(blockchain, rpcs || []);
             return [blockchain, adapter || null];
-            if (adapter) {
-                this.logger?.customLog(`Creating adapter for ${blockchain} blockchain`);
-                return [blockchain, adapter];
-            }
-            this.logger?.customWarn(`Failed to create adapter for ${blockchain} blockchain`);
-            return [blockchain, null];
         });
-        const tonAdapter = this.createAdapter(core_1.BLOCKCHAIN_NAME.TON, []);
-        adapters.push(tonAdapter ? [core_1.BLOCKCHAIN_NAME.TON, tonAdapter] : [core_1.BLOCKCHAIN_NAME.TON, null]);
         const activeAdapters = adapters.filter(([blockchain, adapter]) => {
             const adapterExists = Boolean(adapter);
-            const message = adapterExists ? `Creating adapter for ${blockchain} blockchain` : `Failed to create adapter for ${blockchain} blockchain`;
+            const message = adapterExists
+                ? `Creating adapter for ${blockchain} blockchain`
+                : `Failed to create adapter for ${blockchain} blockchain`;
             this.logger?.customLog(message);
             return adapterExists;
         });
         const store = Object.fromEntries(activeAdapters);
         this.logger?.customLog('Adapters store created');
+        if (!this.clientParams?.lazyLoadWeb3) {
+            Object.values(store).forEach((adapter) => adapter.initWeb3Client());
+        }
         return store;
     }
     createAdapter(blockchain, rpcs) {
-        if (rpcs.length > 0 && typeof rpcs[0] === 'string') {
+        if (rpcs.length > 0) {
             const blockchainType = core_1.BlockchainsInfo.getChainType(blockchain);
             if (blockchainType === core_1.CHAIN_TYPE.EVM) {
                 if (viem_blockchain_mapping_1.viemBlockchainMapping?.[blockchain]) {
-                    return new evm_adapter_1.EvmAdapter({
+                    return new evm_adapter_1.EvmAdapter(this.httpClient, {
                         blockchain: blockchain,
                         rpcList: rpcs
-                    }, this.createLogger?.(`EVM_ADAPTER_${blockchain}`));
+                    }, this.createLogger?.(`EVM_ADAPTER_${blockchain}`), this.clientParams);
                 }
             }
             if (blockchainType === core_1.CHAIN_TYPE.TRON) {
-                return new tron_adapter_1.TronAdapter(rpcs, this.createLogger?.(`TRON_ADAPTER`));
+                return new tron_adapter_1.TronAdapter(rpcs, this.httpClient, this.createLogger?.(`TRON_ADAPTER`), this.clientParams);
+            }
+            if (blockchainType === core_1.CHAIN_TYPE.SUI) {
+                return new sui_adapter_1.SuiAdapter(rpcs, this.httpClient, this.createLogger?.(`SUI_ADAPTER`), this.clientParams);
             }
             if (blockchainType === core_1.CHAIN_TYPE.SOLANA) {
-                return new solana_adapter_1.SolanaAdapter(rpcs, this.createLogger?.(`SOLANA_ADAPTER`));
+                return new solana_adapter_1.SolanaAdapter(rpcs, this.httpClient, this.createLogger?.(`SOLANA_ADAPTER`), this.clientParams);
+            }
+            if (blockchain === core_1.BLOCKCHAIN_NAME.STELLAR) {
+                return new stellar_adapter_1.StellarAdapter(rpcs, this.httpClient, this.logger, this.clientParams);
             }
         }
-        if (blockchain === core_1.BLOCKCHAIN_NAME.TON && this.httpClient && this.tonParams?.tonApiConfig && this.tonParams?.tonClientConfig) {
-            return new ton_adapter_1.TonAdapter(this.httpClient, this.tonParams, this.createLogger?.(`TON_ADAPTER`));
+        if (blockchain === core_1.BLOCKCHAIN_NAME.TON && this.tonParams?.tonApiConfig && this.tonParams?.tonClientConfig) {
+            return new ton_adapter_1.TonAdapter(this.httpClient, this.tonParams, this.createLogger?.(`TON_ADAPTER`), this.clientParams);
         }
-        else {
+        if (blockchain === core_1.BLOCKCHAIN_NAME.BITCOIN && this.httpClient) {
+            return new bitcoin_adapter_1.BitcoinAdapter(this.httpClient, this.createLogger?.(`BTC_ADAPTER`), this.clientParams);
         }
         return null;
     }
-    connectWallet(walletProvider) {
-        if (walletProvider?.[core_1.CHAIN_TYPE.EVM]?.core) {
-            Object.entries(this.adapterStore).forEach(([blockchain, adapter]) => {
-                const provider = walletProvider[core_1.CHAIN_TYPE.EVM].core;
-                const chain = viem_blockchain_mapping_1.viemBlockchainMapping[blockchain];
-                adapter.wallet = (0, viem_1.createWalletClient)({
-                    chain: chain,
-                    transport: (0, viem_1.custom)(provider)
-                });
-                adapter.walletAddress = walletProvider[core_1.CHAIN_TYPE.EVM].address;
-            });
-        }
-        if (walletProvider?.[core_1.CHAIN_TYPE.SOLANA]?.core && this.adapterStore?.[core_1.BLOCKCHAIN_NAME.SOLANA]) {
-            const store = this.adapterStore[core_1.BLOCKCHAIN_NAME.SOLANA];
-            store.wallet = walletProvider[core_1.CHAIN_TYPE.SOLANA].core;
-            store.walletAddress = walletProvider[core_1.CHAIN_TYPE.SOLANA].address;
-        }
-        if (walletProvider?.[core_1.CHAIN_TYPE.TRON]?.core && this.adapterStore?.[core_1.BLOCKCHAIN_NAME.TRON]) {
-            const store = this.adapterStore[core_1.BLOCKCHAIN_NAME.TRON];
-            store.wallet = walletProvider[core_1.CHAIN_TYPE.TRON].core;
-            store.walletAddress = walletProvider[core_1.CHAIN_TYPE.TRON].address;
-        }
-        if (walletProvider?.[core_1.CHAIN_TYPE.TON]?.core && this.adapterStore?.[core_1.BLOCKCHAIN_NAME.TON]) {
-            const store = this.adapterStore[core_1.BLOCKCHAIN_NAME.TON];
-            store.wallet = walletProvider[core_1.CHAIN_TYPE.TON].core;
-            store.walletAddress = walletProvider[core_1.CHAIN_TYPE.TON].address;
-        }
+    connectWallet(blockchain, wallet) {
+        /**
+         * evm chains has many EvmAdapter instances
+         * if you change network before swap - you need to be sure that
+         * EvmAdapter.signer.wallet and EvmAdapter.signer.walletAddress already set
+         */
+        const chainTypeAdapters = Object.values(this.adapterStore).filter((adapter) => core_1.BlockchainsInfo.getChainType(adapter.blockchain) === core_1.BlockchainsInfo.getChainType(blockchain));
+        chainTypeAdapters.forEach((adapter) => {
+            adapter.signer.setWalletAddress(wallet.address);
+            adapter.signer.setWallet(wallet.core);
+            if (!adapter.connected) {
+                adapter.initWeb3Client();
+                const msg = `Web3 client for ${adapter.constructor.name} initialized successfully.`;
+                if (this.clientParams?.envType == 'local') {
+                    this.logger ? this.logger?.customLog(msg, adapter) : console.debug(msg, adapter);
+                }
+            }
+        });
     }
 }
 exports.BlockchainAdapterFactoryService = BlockchainAdapterFactoryService;

package/src/lib/adapter/constants/chain-configs/chain-configs.d.ts

@@ -1,3 +1,3 @@
+import { EvmBlockchainName } from '@cryptorubic/core';
 import { ViemChain } from '../models/viem-chain-type';
-import { EvmBlockchainName } from "@cryptorubic/core";
 export declare const viemConfig: Partial<Record<EvmBlockchainName, ViemChain>>;