@cryptorubic/web3 0.13.0-alpha.solana-gas.11 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "0.13.0-alpha.solana-gas.11",
+    "version": "0.13.0",
     "dependencies": {
         "@ethersproject/bignumber": "^5.8.0",
         "@mysten/sui": "^1.24.0",
@@ -14,7 +14,6 @@
         "bitcoin-address-validation": "^2.2.3",
         "bs58": "^6.0.0",
         "crc-32": "^1.2.2",
-        "ethers": "*",
         "js-base64": "^3.7.8",
         "tronweb": "^6.0.0-beta.4",
         "tslib": "*",

package/src/lib/adapter/adapters/abstract-adapter.js

@@ -3,9 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractAdapter = void 0;
 const viem_1 = require("viem");
 class AbstractAdapter {
-    logger;
-    blockchain;
-    _public = null;
     set public(value) {
         this._public = value;
     }
@@ -17,7 +14,6 @@ class AbstractAdapter {
         }
         return this._public;
     }
-    _wallet = null;
     set wallet(value) {
         this._wallet = value;
     }
@@ -29,7 +25,6 @@ class AbstractAdapter {
         }
         return this._wallet;
     }
-    _walletAddress = null;
     set walletAddress(value) {
         this._walletAddress = value;
     }
@@ -42,6 +37,9 @@ class AbstractAdapter {
         return this._walletAddress;
     }
     constructor(blockchain, logger) {
+        this._public = null;
+        this._wallet = null;
+        this._walletAddress = null;
         this.blockchain = blockchain;
         if (logger) {
             this.logger = logger;

package/src/lib/adapter/adapters/bitcoin-adapter.js

@@ -5,7 +5,6 @@ const core_1 = require("@cryptorubic/core");
 const bignumber_js_1 = require("bignumber.js");
 const abstract_adapter_1 = require("./abstract-adapter");
 class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
-    httpClient;
     constructor(httpClient, logger) {
         super(core_1.BLOCKCHAIN_NAME.BITCOIN, logger);
         this.httpClient = httpClient;

package/src/lib/adapter/adapters/evm-adapter.js

@@ -34,22 +34,21 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             return null;
         }
         const transports = rpcList.map((rpc) => (0, viem_1.http)(rpc, {
-            batch: { batchSize: 2_000, wait: 16 },
+            batch: { batchSize: 2000, wait: 16 },
             onFetchResponse: (response) => {
                 this.handlePossibleError(response);
             },
             retryCount: 2,
             retryDelay: 100,
-            timeout: 5_000
+            timeout: 5000
         }));
         const chain = viem_blockchain_mapping_1.viemBlockchainMapping[this.blockchain];
-        // @ts-ignore
         return (0, viem_1.createPublicClient)({
             // @ts-ignore
             chain,
             transport: (0, viem_1.fallback)(transports, {
                 rank: {
-                    interval: 1_800_000
+                    interval: 1800000
                 }
             })
         });
@@ -136,7 +135,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             throw err;
         }
     }
-    async simulateTransaction(config, from, timeout = 15_000) {
+    async simulateTransaction(config, from, timeout = 15000) {
         try {
             const callParams = {
                 account: from,
@@ -279,7 +278,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             to: tx.to
         };
     }
-    async approveOnPermit2(fromAddress, tokenAddress, permit2Address, spenderAddress, deadline = new bignumber_js_1.default(1_000_000), amount) {
+    async approveOnPermit2(fromAddress, tokenAddress, permit2Address, spenderAddress, deadline = new bignumber_js_1.default(1000000), amount) {
         const approveAmount = amount ? amount : new bignumber_js_1.default(2).pow(256).minus(1);
         const expiration = new bignumber_js_1.default(Date.now()).plus(deadline).toFixed();
         const tx = this.encodePermit2Approve(tokenAddress, spenderAddress, permit2Address, expiration, approveAmount.toFixed());

package/src/lib/adapter/adapters/models/tonapi-models.d.ts

@@ -72,13 +72,13 @@ export interface TonApiTokenInfoForWalletResp {
             [k: string]: string;
         };
     };
-    wallet_address: {
+    wallet_address?: {
         /** address of user's contract for this token */
         address: string;
         is_scam: boolean;
         is_wallet: boolean;
     };
-    jetton: {
+    jetton?: {
         /** address of token(jetton) contract. Similaer to ERC20 contract address in EVM */
         address: string;
         name: string;

package/src/lib/adapter/adapters/solana-adapter.d.ts

@@ -2,11 +2,10 @@ import { Abi, MulticallResponse, MulticallParameters } from 'viem';
 import { AbstractAdapter } from './abstract-adapter';
 import { AddressLookupTableAccount, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
 import { HttpClient, ICustomLogger, PriceTokenAmount, SolanaBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
+import { EvmTransactionConfig } from '../../utils/models/evm-transaction-config';
 import BigNumber from 'bignumber.js';
 import { SolanaRawInstruction } from './models/solana-web3-types';
-import { SolanaTxConfig } from '../../utils/models/solana-transaction-config';
 export declare const NATIVE_SOLANA_MINT_ADDRESS = "So11111111111111111111111111111111111111111";
-export declare const DEFAULT_CU_LIMIT = 400000;
 export declare class SolanaAdapter extends AbstractAdapter<Connection, Connection, SolanaBlockchainName> {
     private readonly httpClient;
     constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger);
@@ -15,9 +14,7 @@ export declare class SolanaAdapter extends AbstractAdapter<Connection, Connectio
     write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
     multicallByContract<T>(_contracts: MulticallParameters, _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
     multicallByAddress<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[][], _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    simulateTransaction(config: SolanaTxConfig, timeout?: number): Promise<string>;
-    private getFailedIxProgramId;
-    private getAddressLookupTableAccounts;
+    simulateTransaction(_config: EvmTransactionConfig, _from: string): Promise<void>;
     checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
     getBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
     /**

package/src/lib/adapter/adapters/solana-adapter.js

@@ -1,21 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaAdapter = exports.DEFAULT_CU_LIMIT = exports.NATIVE_SOLANA_MINT_ADDRESS = void 0;
+exports.SolanaAdapter = exports.NATIVE_SOLANA_MINT_ADDRESS = void 0;
 const spl_token_1 = require("@solana/spl-token");
 const abstract_adapter_1 = require("./abstract-adapter");
 const web3_js_1 = require("@solana/web3.js");
 const core_1 = require("@cryptorubic/core");
 const web3_pure_1 = require("../../utils/web3-pure");
 const bignumber_js_1 = require("bignumber.js");
+const solana_tokens_service_1 = require("./utils/solana-tokens-service");
 const bs58_1 = require("bs58");
 const js_base64_1 = require("js-base64");
-const solana_tokens_service_1 = require("./utils/solana-utils/solana-tokens-service");
-const timeout_1 = require("./utils/timeout");
 exports.NATIVE_SOLANA_MINT_ADDRESS = 'So11111111111111111111111111111111111111111';
-/* minimal amount for tx (in lamports) */
-exports.DEFAULT_CU_LIMIT = 400_000;
 class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
-    httpClient;
     constructor(rpcList, httpClient, logger) {
         super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
         this.httpClient = httpClient;
@@ -42,67 +38,7 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
     async multicallByAddress(_address, _abi, _method, _methodArgs = [], _allowErrors = true) {
         throw new Error('Method multicall is not supported');
     }
-    async simulateTransaction(config, timeout = 15_000) {
-        try {
-            const bufferData = config.data.startsWith('0x') ? Buffer.from(config.data.slice(2), 'hex') : Buffer.from(config.data, 'base64');
-            const { blockhash } = await this.public.getLatestBlockhash();
-            const tx = web3_js_1.VersionedTransaction.deserialize(bufferData);
-            tx.message.recentBlockhash = blockhash;
-            const simulation = this.public.simulateTransaction(tx, {
-                replaceRecentBlockhash: true,
-                commitment: 'confirmed',
-                accounts: {
-                    encoding: 'base64',
-                    addresses: [config.walletAddress]
-                }
-            });
-            const resp = await (0, timeout_1.withTimeout)(simulation, timeout, 'Solana Simulation Timeout!');
-            const err = resp.value.err;
-            const defineCuLimit = () => {
-                const cuLimit = resp.value.unitsConsumed || 0;
-                const defaultGreaterEstimated = new bignumber_js_1.default(exports.DEFAULT_CU_LIMIT).gt(cuLimit);
-                return new bignumber_js_1.default(defaultGreaterEstimated ? exports.DEFAULT_CU_LIMIT : cuLimit).toFixed(0);
-            };
-            if (err) {
-                if (Array.isArray(err['InstructionError'])) {
-                    const [failedInstructionIdx, errorData] = err['InstructionError'];
-                    const failedInstructionProgramId = await this.getFailedIxProgramId(tx, failedInstructionIdx);
-                    this.logger?.customLog('FAILED INSTRUCTION INFO', { programId: failedInstructionProgramId, errorData });
-                    const weirdError = errorData?.Custom === 1;
-                    if (weirdError)
-                        return defineCuLimit();
-                }
-                throw new Error('Transaction simulation failed.');
-            }
-            return defineCuLimit();
-        }
-        catch (err) {
-            this.logger?.customError('Error while simulating transaction', err);
-            throw err;
-        }
-    }
-    async getFailedIxProgramId(tx, failedInstructionIdx) {
-        const lutKeys = (tx.message.addressTableLookups ?? []).map((l) => l.accountKey.toBase58());
-        const lutAccounts = lutKeys.length ? await this.getAddressLookupTableAccounts(lutKeys) : [];
-        const decompiled = web3_js_1.TransactionMessage.decompile(tx.message, { addressLookupTableAccounts: lutAccounts });
-        const programId = decompiled.instructions[failedInstructionIdx].programId;
-        return programId.toBase58();
-    }
-    async getAddressLookupTableAccounts(keys) {
-        const result = [];
-        const infos = await this.public.getMultipleAccountsInfo(keys.map((k) => new web3_js_1.PublicKey(k)));
-        keys.forEach((address, i) => {
-            const ai = infos[i];
-            if (ai) {
-                const alt = new web3_js_1.AddressLookupTableAccount({
-                    key: new web3_js_1.PublicKey(address),
-                    state: web3_js_1.AddressLookupTableAccount.deserialize(ai.data)
-                });
-                result.push(alt);
-            }
-        });
-        return result;
-    }
+    async simulateTransaction(_config, _from) { }
     async checkEnoughBalance(token, walletAddress) {
         const balance = await this.getBalance(walletAddress, token.address);
         return balance.gte(token.tokenAmount);

package/src/lib/adapter/adapters/ton-adapter.js

@@ -8,11 +8,9 @@ const bignumber_js_1 = require("bignumber.js");
 const abstract_adapter_1 = require("./abstract-adapter");
 const web3_pure_1 = require("../../utils/web3-pure");
 class TonAdapter extends abstract_adapter_1.AbstractAdapter {
-    tonApi;
-    tonClient;
     constructor(httpClient, config, logger) {
         super(core_1.BLOCKCHAIN_NAME.TON, logger);
-        this.tonApi = new ton_api_service_1.TonApiService(httpClient, config.tonApiConfig);
+        this.tonApi = new ton_api_service_1.TonApiService(httpClient, config.tonApiConfig, logger);
         this.tonClient = new ton_1.TonClient(config.tonClientConfig);
     }
     async callForTokensInfo(tokenAddresses) {

package/src/lib/adapter/adapters/tron-adapter.js

@@ -10,13 +10,13 @@ const core_1 = require("@cryptorubic/core");
 const web3_pure_1 = require("../../utils/web3-pure");
 const tron_web3_pure_1 = require("../../utils/web3-types/tron-web3-pure");
 class TronAdapter extends abstract_adapter_1.AbstractAdapter {
-    multicallAddress = 'T9ziQU4EBteJzjzMzhHELdhgWFqwzS5Vki';
     async needPreswapAction(token, contractAddress, walletAddress, amount) {
         // return this.needApprove()
         return false;
     }
     constructor(rpcList, logger) {
         super(core_1.BLOCKCHAIN_NAME.TRON, logger);
+        this.multicallAddress = 'T9ziQU4EBteJzjzMzhHELdhgWFqwzS5Vki';
         this.public = new tronweb_1.TronWeb({ fullHost: rpcList[0] });
     }
     async checkEnoughBalance(token, walletAddress) {

package/src/lib/adapter/adapters/utils/{solana-utils/solana-tokens-service.d.ts → solana-tokens-service.d.ts}

@@ -1,6 +1,6 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import { HttpClient } from '@cryptorubic/core';
-import { SolanaToken } from '../../models/solana-web3-types';
+import { SolanaToken } from '../models/solana-web3-types';
 export declare class SolanaTokensService {
     private readonly httpClient;
     private connection;

package/src/lib/adapter/adapters/utils/{solana-utils/solana-tokens-service.js → solana-tokens-service.js}

@@ -3,18 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaTokensService = void 0;
 const spl_token_1 = require("@solana/spl-token");
 const utl_sdk_1 = require("@solflare-wallet/utl-sdk");
-const timeout_1 = require("../timeout");
+const timeout_1 = require("./timeout");
 class SolanaTokensService {
-    httpClient;
-    connection;
-    // key - address of token, value - idx of token in initial tokensAddress
-    tokensOrder = {};
-    initialMints = [];
-    apiEndpoint = 'https://x-api.rubic.exchange/sol_token_list';
-    newTokensEndpoint = 'https://api.rubic.exchange/api/v2';
-    xApiKey = 'sndfje3u4b3fnNSDNFUSDNVSunw345842hrnfd3b4nt4';
     constructor(connection, httpClient) {
         this.httpClient = httpClient;
+        // key - address of token, value - idx of token in initial tokensAddress
+        this.tokensOrder = {};
+        this.initialMints = [];
+        this.apiEndpoint = 'https://x-api.rubic.exchange/sol_token_list';
+        this.newTokensEndpoint = 'https://api.rubic.exchange/api/v2';
+        this.xApiKey = 'sndfje3u4b3fnNSDNFUSDNVSunw345842hrnfd3b4nt4';
         this.connection = connection;
     }
     async fetchTokensData(mints) {
@@ -59,7 +57,7 @@ class SolanaTokensService {
     }
     async fetchTokensFromOldBackend(mints, prevFetchedTokens) {
         const tokensAddresses = mints.map((mint) => mint.toString());
-        const { content: tokensFromOlbBackend } = await (0, timeout_1.withTimeout)(this.getTokensListOld(tokensAddresses), 3_000, 'Api Timeout!').catch(() => ({ content: [] }));
+        const { content: tokensFromOlbBackend } = await (0, timeout_1.withTimeout)(this.getTokensListOld(tokensAddresses), 3000, 'Api Timeout!').catch(() => ({ content: [] }));
         const notSortedTokensList = [...prevFetchedTokens, ...tokensFromOlbBackend];
         const notFetchedMints = this.getNotFetchedTokensList(notSortedTokensList);
         return {

package/src/lib/adapter/adapters/utils/ton-api.service.d.ts

@@ -1,14 +1,15 @@
 import { TonApiAccountInfoResp, TonApiAllNonNullableTokenInfoForWalletResp, TonApiParseAddressResp, TonApiTokenInfoForWalletResp, TonApiTokenInfoResp, TonApiTxDataByBocResp } from '../models/tonapi-models';
 import { TonCenterBlockInfo } from '../models/toncenter-types';
-import { HttpClient } from '@cryptorubic/core';
+import { HttpClient, ICustomLogger } from '@cryptorubic/core';
 import { TonApiConfig } from '../models/ton-api-config';
 import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
 export declare class TonApiService {
     private readonly httpClient;
+    private readonly logger?;
     private readonly tonApiUrl;
     private readonly apiKey;
     private readonly tonCenterV3Url;
-    constructor(httpClient: HttpClient, params: TonApiConfig);
+    constructor(httpClient: HttpClient, params: TonApiConfig, logger?: ICustomLogger | undefined);
     /**
      * @param walletAddress in any format: raw or friendly
      */

package/src/lib/adapter/adapters/utils/ton-api.service.js

@@ -2,12 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TonApiService = void 0;
 class TonApiService {
-    httpClient;
-    tonApiUrl;
-    apiKey;
-    tonCenterV3Url;
-    constructor(httpClient, params) {
+    constructor(httpClient, params, logger) {
         this.httpClient = httpClient;
+        this.logger = logger;
         this.apiKey = params.tonApiKey;
         this.tonApiUrl = params?.tonApiUrl || 'https://tonapi.io';
         this.tonCenterV3Url = params.tonCenterV3Url || 'https://toncenter.com/api/v3';
@@ -152,16 +149,23 @@ class TonApiService {
      * @returns balance, decimals, name, symbol, walletJettonAddress, jettonAddress
      */
     async fetchTokenInfoForWallet(walletAddress, tokenAddress) {
-        const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}/jettons/${tokenAddress}`, {
-            headers: {
-                apiKey: this.apiKey,
-                referer: 'https://app.rubic.exchange'
+        try {
+            const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}/jettons/${tokenAddress}`, {
+                headers: {
+                    apiKey: this.apiKey,
+                    referer: 'https://app.rubic.exchange'
+                }
+            });
+            if ('error' in res) {
+                this.logger?.customError('[TonApiService] ERROR IN fetchTokenInfoForWallet', res.error);
+                return { balance: '0' };
             }
-        });
-        if ('error' in res) {
-            throw new Error(`[TonApiService] Error in fetchTokenInfoForWallet - ${res.error}`);
+            return res;
+        }
+        catch (err) {
+            this.logger?.customError('[TonApiService] ERROR IN fetchTokenInfoForWallet', err);
+            return { balance: '0' };
         }
-        return res;
     }
     async fetchAllNonNullableTokensInfoForWallet(walletAddress) {
         const res = await this.httpClient.get(`${this.tonApiUrl}/v2/accounts/${walletAddress}/jettons`, {

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

@@ -2,19 +2,21 @@ 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, TonBlockchainName, BitcoinBlockchainName, SuiBlockchainName } from '@cryptorubic/core';
+import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, HttpClient, TonBlockchainName, BitcoinBlockchainName, SuiBlockchainName } from '@cryptorubic/core';
 import { TonAdapter } from './adapters/ton-adapter';
+import { TonAdapterConfig } from './adapters/models/ton-adapter-config';
 import { EvmAdapter } from './adapters/evm-adapter';
 import { BitcoinAdapter } from './adapters/bitcoin-adapter';
 import { SuiAdapter } from './adapters/sui-adapter';
-import { AdaptersFactoryParams } from './adapters/models/adapter-factory-params';
 export declare class BlockchainAdapterFactoryService {
     private readonly rpcList;
-    private readonly params;
+    private readonly createLogger?;
+    private readonly httpClient?;
+    private readonly tonParams?;
     readonly adapterStore: Partial<Record<BlockchainName, AbstractAdapter<unknown, unknown, BlockchainName>>>;
     protected readonly logger?: ICustomLogger;
     private constructor();
-    static createFactory(rpcList: Partial<Record<EvmBlockchainName, string[]>>, params: AdaptersFactoryParams): Promise<BlockchainAdapterFactoryService>;
+    static createFactory(rpcList: Partial<Record<EvmBlockchainName, string[]>>, httpClient?: HttpClient, tonParams?: TonAdapterConfig, createLogger?: (label: string) => ICustomLogger): Promise<BlockchainAdapterFactoryService>;
     getAdapter(blockchain: SolanaBlockchainName): SolanaAdapter;
     getAdapter(blockchain: EvmBlockchainName): EvmAdapter;
     getAdapter(blockchain: TronBlockchainName): TronAdapter;

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

@@ -11,24 +11,22 @@ const evm_adapter_1 = require("./adapters/evm-adapter");
 const bitcoin_adapter_1 = require("./adapters/bitcoin-adapter");
 const sui_adapter_1 = require("./adapters/sui-adapter");
 class BlockchainAdapterFactoryService {
-    rpcList;
-    params;
-    adapterStore = {};
-    logger;
-    constructor(rpcList, params) {
+    constructor(rpcList, createLogger, httpClient, tonParams) {
         this.rpcList = rpcList;
-        this.params = params;
+        this.createLogger = createLogger;
+        this.httpClient = httpClient;
+        this.tonParams = tonParams;
+        this.adapterStore = {};
         this.adapterStore = this.createStorage();
-        if (this.params.createLogger) {
-            this.logger = this.params.createLogger('BlockchainAdapterFactory');
+        if (this.createLogger) {
+            this.logger = this.createLogger('BlockchainAdapterFactory');
         }
     }
-    static async createFactory(rpcList, params) {
+    static async createFactory(rpcList, httpClient, tonParams, createLogger) {
         // @TODO Add default logger
-        const loggerFn = params.createLogger || undefined;
-        const resolvedHttpClient = params.httpClient ?? (await Promise.resolve().then(() => require('axios')));
-        params.httpClient = resolvedHttpClient;
-        return new this(rpcList, params);
+        const loggerFn = createLogger || undefined;
+        const resolvedHttpClient = httpClient ?? (await Promise.resolve().then(() => require('axios')));
+        return new this(rpcList, createLogger, resolvedHttpClient, tonParams);
     }
     getAdapter(blockchain) {
         const adapter = this.adapterStore?.[blockchain];
@@ -66,24 +64,24 @@ class BlockchainAdapterFactoryService {
                     return new evm_adapter_1.EvmAdapter({
                         blockchain: blockchain,
                         rpcList: rpcs
-                    }, this.params.createLogger?.(`EVM_ADAPTER_${blockchain}`));
+                    }, this.createLogger?.(`EVM_ADAPTER_${blockchain}`));
                 }
             }
             if (blockchainType === core_1.CHAIN_TYPE.TRON) {
-                return new tron_adapter_1.TronAdapter(rpcs, this.params.createLogger?.(`TRON_ADAPTER`));
+                return new tron_adapter_1.TronAdapter(rpcs, this.createLogger?.(`TRON_ADAPTER`));
             }
             if (blockchainType === core_1.CHAIN_TYPE.SUI) {
-                return new sui_adapter_1.SuiAdapter(rpcs, this.params.createLogger?.(`SUI_ADAPTER`));
+                return new sui_adapter_1.SuiAdapter(rpcs, this.createLogger?.(`SUI_ADAPTER`));
             }
             if (blockchainType === core_1.CHAIN_TYPE.SOLANA) {
-                return new solana_adapter_1.SolanaAdapter(rpcs, this.params.httpClient, this.params.createLogger?.(`SOLANA_ADAPTER`));
+                return new solana_adapter_1.SolanaAdapter(rpcs, this.httpClient, this.createLogger?.(`SOLANA_ADAPTER`));
             }
         }
-        if (blockchain === core_1.BLOCKCHAIN_NAME.TON && this.params.tonParams?.tonApiConfig && this.params.tonParams?.tonClientConfig) {
-            return new ton_adapter_1.TonAdapter(this.params.httpClient, this.params.tonParams, this.params.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`));
         }
-        if (blockchain === core_1.BLOCKCHAIN_NAME.BITCOIN && this.params.httpClient) {
-            return new bitcoin_adapter_1.BitcoinAdapter(this.params.httpClient, this.params.createLogger?.(`BTC_ADAPTER`));
+        if (blockchain === core_1.BLOCKCHAIN_NAME.BITCOIN && this.httpClient) {
+            return new bitcoin_adapter_1.BitcoinAdapter(this.httpClient, this.createLogger?.(`BTC_ADAPTER`));
         }
         return null;
     }

package/src/lib/utils/web3-types/common-web3-pure.js

@@ -3,11 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonWeb3Pure = void 0;
 const axios_1 = require("axios");
 class CommonWeb3Pure {
-    nativeTokenAddress = '0x0000000000000000000000000000000000000000';
-    emptyAddress = '0x0000000000000000000000000000000000000000';
-    cnApiKey;
-    regEx;
     constructor(commonParams) {
+        this.nativeTokenAddress = '0x0000000000000000000000000000000000000000';
+        this.emptyAddress = '0x0000000000000000000000000000000000000000';
         this.cnApiKey = commonParams?.cnApiKey || undefined;
         this.regEx = commonParams?.regex || undefined;
     }

package/src/lib/utils/web3-types/solana-web3-pure.js

@@ -5,12 +5,12 @@ const changenow_api_blockchain_1 = require("../constants/changenow-api-blockchai
 const common_web3_pure_1 = require("./common-web3-pure");
 const core_1 = require("@cryptorubic/core");
 class SolanaWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
-    nativeTokenAddress = 'So11111111111111111111111111111111111111111';
     constructor() {
         super({
             cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.SOLANA,
             regex: /^(?!.*([1-9A-HJ-NP-Za-km-z])\1{31,43}$)[1-9A-HJ-NP-Za-km-z]{32,44}$/
         });
+        this.nativeTokenAddress = 'So11111111111111111111111111111111111111111';
     }
     async isAddressCorrect(address) {
         if ((0, core_1.compareAddresses)(address, this.nativeTokenAddress)) {

package/src/lib/utils/web3-types/sui-web3-pure.js

@@ -5,8 +5,6 @@ const common_web3_pure_1 = require("./common-web3-pure");
 const core_1 = require("@cryptorubic/core");
 const bignumber_js_1 = require("bignumber.js");
 class SuiWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
-    nativeTokenAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
-    emptyAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
     static compareAddress(addressA, addressB) {
         const pureAddressA = addressA.split(':')[0];
         const pureAddressB = addressB.split(':')[0];
@@ -22,6 +20,8 @@ class SuiWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
         super({
             regex: /(^0[xX][a-fA-F0-9]{0,64}::[a-zA-Z0-9_]*::[A-Z0-9_]*$)|(^0[xX][a-fA-F0-9]{64}$)/
         });
+        this.nativeTokenAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+        this.emptyAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
     }
 }
 exports.SuiWeb3Pure = SuiWeb3Pure;

package/src/lib/adapter/adapters/models/adapter-factory-params.d.ts

@@ -1,7 +0,0 @@
-import { HttpClient, ICustomLogger } from '@cryptorubic/core';
-import { TonAdapterConfig } from './ton-adapter-config';
-export interface AdaptersFactoryParams {
-    tonParams: TonAdapterConfig;
-    httpClient?: HttpClient;
-    createLogger?: (label: string) => ICustomLogger;
-}

package/src/lib/adapter/adapters/models/adapter-factory-params.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/src/lib/utils/models/solana-transaction-config.d.ts

@@ -1,6 +0,0 @@
-type Base64String = `AQA${string}`;
-export interface SolanaTxConfig {
-    data: Base64String;
-    walletAddress: string;
-}
-export {};

package/src/lib/utils/models/solana-transaction-config.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });