@cryptorubic/web3 0.8.17-alpha.solana.1 → 0.8.17-alpha.solana.10

package/package.json

@@ -1,27 +1,26 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "0.8.17-alpha.solana.1",
+    "version": "0.8.17-alpha.solana.10",
     "dependencies": {
-        "tslib": "^2.3.0",
-        "bignumber.js": "9.1.2",
-        "@cryptorubic/core": "0.8.17-alpha.solana.1",
-        "viem": "^2.19.1",
-        "web3-utils": "^4.3.1",
-        "@ton/ton": "^15.1.0",
+        "@ethersproject/bignumber": "^5.8.0",
+        "@mysten/sui": "^1.24.0",
+        "@solana/spl-token": "*",
         "@solana/web3.js": "1.95.3",
         "@solflare-wallet/utl-sdk": "^1.4.0",
-        "@ethersproject/bignumber": "^5.7.0",
-        "@cryptorubic/tron-types": "0.8.17-alpha.solana.1",
+        "@suiet/wallet-sdk": "^0.3.3",
+        "@ton/ton": "^15.1.0",
+        "axios": "*",
+        "bignumber.js": "9.1.2",
         "bitcoin-address-validation": "^2.2.3",
-        "axios": "0.27.2",
+        "bs58": "^6.0.0",
         "crc-32": "^1.2.2",
+        "ethers": "*",
+        "js-base64": "^3.7.8",
         "tronweb": "^6.0.0-beta.4",
-        "@solana/spl-token": "0.2.0",
-        "@mysten/sui": "^1.24.0",
-        "@suiet/wallet-sdk": "^0.3.3",
-        "bs58": "^6.0.0",
-        "ethers": "5.7.2"
+        "tslib": "*",
+        "viem": "^2.33.1"
     },
+    "peerDependencies": {},
     "type": "commonjs",
     "main": "./src/index.js",
     "typings": "./src/index.d.ts",
@@ -31,5 +30,12 @@
     "author": {
         "name": "Sleta Dmitrii"
     },
+    "exports": {
+        "./package.json": "./package.json",
+        ".": {
+            "types": "./src/index.d.ts",
+            "default": "./src/index.js"
+        }
+    },
     "types": "./src/index.d.ts"
 }

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

@@ -3,6 +3,9 @@ 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;
     }
@@ -14,6 +17,7 @@ class AbstractAdapter {
         }
         return this._public;
     }
+    _wallet = null;
     set wallet(value) {
         this._wallet = value;
     }
@@ -25,6 +29,7 @@ class AbstractAdapter {
         }
         return this._wallet;
     }
+    _walletAddress = null;
     set walletAddress(value) {
         this._walletAddress = value;
     }
@@ -37,9 +42,6 @@ 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,6 +5,7 @@ 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/constants/tron-multicall-abi.d.ts

@@ -1,2 +1,2 @@
-import { AbiItem } from 'web3-utils';
+import { AbiItem } from '../../../utils/models/abi-types';
 export declare const TRON_MULTICALL_ABI: AbiItem[];

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

@@ -34,21 +34,22 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             return null;
         }
         const transports = rpcList.map((rpc) => (0, viem_1.http)(rpc, {
-            batch: { batchSize: 2000, wait: 16 },
+            batch: { batchSize: 2_000, wait: 16 },
             onFetchResponse: (response) => {
                 this.handlePossibleError(response);
             },
             retryCount: 2,
             retryDelay: 100,
-            timeout: 5000
+            timeout: 5_000
         }));
         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: 1800000
+                    interval: 1_800_000
                 }
             })
         });
@@ -80,7 +81,8 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             to: to,
             value: (0, viem_1.parseEther)(value),
             data: data,
-            chain: this.public.chain
+            chain: this.public.chain,
+            kzg: undefined
         });
         return result;
     }
@@ -135,7 +137,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             throw err;
         }
     }
-    async simulateTransaction(config, from, timeout = 15000) {
+    async simulateTransaction(config, from, timeout = 15_000) {
         try {
             const callParams = {
                 account: from,
@@ -278,7 +280,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             to: tx.to
         };
     }
-    async approveOnPermit2(fromAddress, tokenAddress, permit2Address, spenderAddress, deadline = new bignumber_js_1.default(1000000), amount) {
+    async approveOnPermit2(fromAddress, tokenAddress, permit2Address, spenderAddress, deadline = new bignumber_js_1.default(1_000_000), 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/adapter-factory-params.d.ts

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

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

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

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

@@ -2,7 +2,7 @@ import { BlockchainName, TokenAmount } from '@cryptorubic/core';
 import { AllowanceInfo } from './common-types';
 import { AbstractAdapter } from '../abstract-adapter';
 import { EvmTransactionConfig } from '../../../utils/models/evm-transaction-config';
-import { TronTransactionConfig } from '@cryptorubic/tron-types';
+import { TronTransactionConfig } from '../../../utils/models/tron-transaction-config';
 export interface ApproveAdapter<T> extends AbstractAdapter<any, any, BlockchainName> {
     /**
      * @param fromTokenAddress erc20 address of checked token

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

@@ -0,0 +1,3 @@
+export interface SolanaAdapterConfig {
+    heliusApiKey: string;
+}

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

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

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

@@ -5,11 +5,14 @@ import { HttpClient, ICustomLogger, PriceTokenAmount, SolanaBlockchainName, Toke
 import BigNumber from 'bignumber.js';
 import { SolanaRawInstruction } from './models/solana-web3-types';
 import { SolanaTxConfig } from '../../utils/models/solana-transaction-config';
+import { SolanaAdapterConfig } from './models/solana-adapter-config';
+import { SolanaGasService } from './utils/solana-utils/solana-gas-service';
 export declare const NATIVE_SOLANA_MINT_ADDRESS = "So11111111111111111111111111111111111111111";
 export declare const DEFAULT_CU_LIMIT = 600000;
 export declare class SolanaAdapter extends AbstractAdapter<Connection, Connection, SolanaBlockchainName> {
     private readonly httpClient;
-    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger);
+    readonly gasService: SolanaGasService;
+    constructor(rpcList: string[], httpClient: HttpClient, solanaConfig: SolanaAdapterConfig, logger?: ICustomLogger);
     private createPublicClient;
     read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
     write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;

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

@@ -7,16 +7,20 @@ 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 utils_1 = require("ethers/lib/utils");
+const js_base64_1 = require("js-base64");
+const solana_gas_service_1 = require("./utils/solana-utils/solana-gas-service");
+const solana_tokens_service_1 = require("./utils/solana-utils/solana-tokens-service");
 exports.NATIVE_SOLANA_MINT_ADDRESS = 'So11111111111111111111111111111111111111111';
-exports.DEFAULT_CU_LIMIT = 600000;
+exports.DEFAULT_CU_LIMIT = 600_000;
 class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
-    constructor(rpcList, httpClient, logger) {
+    httpClient;
+    gasService;
+    constructor(rpcList, httpClient, solanaConfig, logger) {
         super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
         this.httpClient = httpClient;
         this.public = this.createPublicClient(rpcList);
+        this.gasService = new solana_gas_service_1.SolanaGasService(httpClient, this.public, solanaConfig);
     }
     createPublicClient(rpcList) {
         if (!rpcList?.[0]) {
@@ -39,7 +43,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 = 15000) {
+    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();
@@ -179,7 +183,7 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
         return new web3_js_1.VersionedTransaction(newMsg);
     }
     deserializeTransaction(data) {
-        const decodedData = data.startsWith('0x') ? Buffer.from(data.slice(2), 'hex') : utils_1.base64.decode(data);
+        const decodedData = data.startsWith('0x') ? Buffer.from(data.slice(2), 'hex') : js_base64_1.Base64.toUint8Array(data);
         return web3_js_1.VersionedTransaction.deserialize(decodedData);
     }
     serializeTransactionToBase58(tx) {

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

@@ -8,6 +8,8 @@ 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);

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

@@ -1,25 +1,26 @@
 import BigNumber from 'bignumber.js';
 import { AbstractAdapter } from './abstract-adapter';
-import { ContractMulticallResponse, MethodData, TronWeb3PrimitiveType } from '@cryptorubic/tron-types';
 import { TronWeb } from 'tronweb';
-import { AbiFragment } from 'tronweb/lib/commonjs/types';
 import { ICustomLogger, PriceTokenAmount, Token, TokenAmount, TronBlockchainName } from '@cryptorubic/core';
 import { TronTransactionConfig } from '../../utils/models/tron-transaction-config';
 import { TronParameters } from '../../utils/models/tron-parameters';
 import { Abi } from 'viem';
 import { ApproveAdapter } from './models/approve-adapter';
 import { AllowanceInfo } from './models/common-types';
+import { ContractMulticallResponse } from '../../utils/models/contract-multicall-response';
+import { TronWeb3PrimitiveType } from '../../utils/models/primitive-types';
+import { MethodData } from '../../utils/models/method-data';
 export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> implements ApproveAdapter<TronTransactionConfig> {
     private readonly multicallAddress;
     needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
     constructor(rpcList: string[], logger?: ICustomLogger);
     checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    multicallContractsMethods<Output extends TronWeb3PrimitiveType>(contractAbi: readonly AbiFragment[], contractsData: {
+    multicallContractsMethods<Output extends TronWeb3PrimitiveType>(contractAbi: any, contractsData: {
         contractAddress: string;
         methodsData: MethodData[];
-    }[]): Promise<ContractMulticallResponse<Output>[][]>;
+    }[]): Promise<ContractMulticallResponse<any>[][]>;
     private multicall;
-    read<T>(contractAddress: string, contractAbi: readonly AbiFragment[], methodName: string, methodArguments?: unknown[]): Promise<T>;
+    read<T>(contractAddress: string, contractAbi: any, methodName: string, methodArguments?: unknown[]): Promise<T>;
     private multicallContractsMethodsByOne;
     getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token[]>;

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-gas-service.d.ts

@@ -0,0 +1,22 @@
+import { HttpClient } from '@cryptorubic/core';
+import { Connection } from '@solana/web3.js';
+import { SolanaAdapterConfig } from '../../models/solana-adapter-config';
+import BigNumber from 'bignumber.js';
+export declare class SolanaGasService {
+    private httpClient;
+    private readonly connection;
+    private readonly HELIUS_API_URL;
+    private readonly HELIUS_API_KEY;
+    constructor(httpClient: HttpClient, connection: Connection, solanaConfig: SolanaAdapterConfig);
+    /**
+     * @returns wei ComputedUnitsLimit - like gasLimit in evm
+     */
+    getConsumedUnitsLimit(txData: string): Promise<BigNumber>;
+    /**
+     * @param txData base64 or hex string
+     * @returns wei ComputedUnitsPrice - like gasPrice in evm
+     */
+    getConsumedUnitsPrice(txData: string): Promise<BigNumber>;
+    private calculateCUPriceHelius;
+    private calculateCUPriceSolWeb3;
+}

package/src/lib/adapter/adapters/utils/solana-utils/solana-gas-service.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaGasService = void 0;
+const utils_1 = require("ethers/lib/utils");
+const utility_funcs_1 = require("./utility-funcs");
+const bignumber_js_1 = require("bignumber.js");
+class SolanaGasService {
+    httpClient;
+    connection;
+    HELIUS_API_URL = 'https://mainnet.helius-rpc.com';
+    HELIUS_API_KEY;
+    constructor(httpClient, connection, solanaConfig) {
+        this.httpClient = httpClient;
+        this.connection = connection;
+        this.HELIUS_API_KEY = solanaConfig.heliusApiKey;
+    }
+    /**
+     * @returns wei ComputedUnitsLimit - like gasLimit in evm
+     */
+    async getConsumedUnitsLimit(txData) {
+        const DEFAULT_CU_LIMIT = 600_000;
+        try {
+            const tx = (0, utility_funcs_1.convertB64DataToTx)(txData);
+            const resp = await this.connection.simulateTransaction(tx, {
+                replaceRecentBlockhash: true
+            });
+            return resp.value.unitsConsumed ? new bignumber_js_1.default(resp.value.unitsConsumed * 1.2) : new bignumber_js_1.default(DEFAULT_CU_LIMIT);
+        }
+        catch (err) {
+            console.error('Solana_simulateTransaction_Error ==> ', err);
+            return new bignumber_js_1.default(DEFAULT_CU_LIMIT);
+        }
+    }
+    /**
+     * @param txData base64 or hex string
+     * @returns wei ComputedUnitsPrice - like gasPrice in evm
+     */
+    async getConsumedUnitsPrice(txData) {
+        if (!this.HELIUS_API_KEY) {
+            console.warn('[SolanaApiService_getConsumedUnitsPrice] heliusApiKey is not provided in "createFactory"');
+        }
+        const cuPrice = await Promise.any([this.calculateCUPriceHelius(txData), this.calculateCUPriceSolWeb3()]);
+        return cuPrice;
+    }
+    async calculateCUPriceHelius(txData) {
+        const tx = (0, utility_funcs_1.convertB64DataToTx)(txData);
+        const resp = await this.httpClient.post(`${this.HELIUS_API_URL}/?api-key=${this.HELIUS_API_KEY}`, {
+            jsonrpc: '2.0',
+            id: '1',
+            method: 'getPriorityFeeEstimate',
+            params: [
+                {
+                    transaction: utils_1.base58.encode(tx.serialize()), // Pass the serialized transaction in Base58
+                    options: { priorityLevel: 'Medium' }
+                }
+            ]
+        });
+        return new bignumber_js_1.default(resp.result.priorityFeeEstimate);
+    }
+    async calculateCUPriceSolWeb3() {
+        const BASE_FEE = 5_000;
+        const resp = await this.connection.getRecentPrioritizationFees();
+        const avgCUPrice = resp
+            .reduce((acc, tx) => acc.plus(tx.prioritizationFee), new bignumber_js_1.default(0))
+            .div(resp.length)
+            .dp(0, bignumber_js_1.default.ROUND_CEIL);
+        const cuPrice = new bignumber_js_1.default(Math.max(BASE_FEE, avgCUPrice.toNumber()));
+        return cuPrice;
+    }
+}
+exports.SolanaGasService = SolanaGasService;

package/src/lib/adapter/adapters/utils/{solana-tokens-service.d.ts → solana-utils/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-tokens-service.js → solana-utils/solana-tokens-service.js}

@@ -3,16 +3,18 @@ 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) {
@@ -57,7 +59,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), 3000, 'Api Timeout!').catch(() => ({ content: [] }));
+        const { content: tokensFromOlbBackend } = await (0, timeout_1.withTimeout)(this.getTokensListOld(tokensAddresses), 3_000, 'Api Timeout!').catch(() => ({ content: [] }));
         const notSortedTokensList = [...prevFetchedTokens, ...tokensFromOlbBackend];
         const notFetchedMints = this.getNotFetchedTokensList(notSortedTokensList);
         return {

package/src/lib/adapter/adapters/utils/solana-utils/utility-funcs.d.ts

@@ -0,0 +1,2 @@
+import { VersionedTransaction } from '@solana/web3.js';
+export declare function convertB64DataToTx(txData: string): VersionedTransaction;

package/src/lib/adapter/adapters/utils/solana-utils/utility-funcs.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertB64DataToTx = convertB64DataToTx;
+const web3_js_1 = require("@solana/web3.js");
+function convertB64DataToTx(txData) {
+    const bufferData = txData.startsWith('0x') ? Buffer.from(txData.slice(2), 'hex') : Buffer.from(txData, 'base64');
+    const tx = web3_js_1.VersionedTransaction.deserialize(bufferData);
+    return tx;
+}

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

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TonApiService = void 0;
 class TonApiService {
+    httpClient;
+    tonApiUrl;
+    apiKey;
+    tonCenterV3Url;
     constructor(httpClient, params) {
         this.httpClient = httpClient;
         this.apiKey = params.tonApiKey;

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

@@ -2,21 +2,19 @@ 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, BitcoinBlockchainName, SuiBlockchainName } from '@cryptorubic/core';
+import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, 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 createLogger?;
-    private readonly httpClient?;
-    private readonly tonParams?;
+    private readonly params;
     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>;
+    static createFactory(rpcList: Partial<Record<EvmBlockchainName, string[]>>, params: AdaptersFactoryParams): Promise<BlockchainAdapterFactoryService>;
     getAdapter(blockchain: SolanaBlockchainName): SolanaAdapter;
     getAdapter(blockchain: EvmBlockchainName): EvmAdapter;
     getAdapter(blockchain: TronBlockchainName): TronAdapter;

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

@@ -11,22 +11,24 @@ 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 {
-    constructor(rpcList, createLogger, httpClient, tonParams) {
+    rpcList;
+    params;
+    adapterStore = {};
+    logger;
+    constructor(rpcList, params) {
         this.rpcList = rpcList;
-        this.createLogger = createLogger;
-        this.httpClient = httpClient;
-        this.tonParams = tonParams;
-        this.adapterStore = {};
+        this.params = params;
         this.adapterStore = this.createStorage();
-        if (this.createLogger) {
-            this.logger = this.createLogger('BlockchainAdapterFactory');
+        if (this.params.createLogger) {
+            this.logger = this.params.createLogger('BlockchainAdapterFactory');
         }
     }
-    static async createFactory(rpcList, httpClient, tonParams, createLogger) {
+    static async createFactory(rpcList, 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')));
+        params.httpClient = resolvedHttpClient;
+        return new this(rpcList, params);
     }
     getAdapter(blockchain) {
         const adapter = this.adapterStore?.[blockchain];
@@ -64,24 +66,24 @@ class BlockchainAdapterFactoryService {
                     return new evm_adapter_1.EvmAdapter({
                         blockchain: blockchain,
                         rpcList: rpcs
-                    }, this.createLogger?.(`EVM_ADAPTER_${blockchain}`));
+                    }, this.params.createLogger?.(`EVM_ADAPTER_${blockchain}`));
                 }
             }
             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.params.createLogger?.(`TRON_ADAPTER`));
             }
             if (blockchainType === core_1.CHAIN_TYPE.SUI) {
-                return new sui_adapter_1.SuiAdapter(rpcs, this.createLogger?.(`SUI_ADAPTER`));
+                return new sui_adapter_1.SuiAdapter(rpcs, this.params.createLogger?.(`SUI_ADAPTER`));
             }
             if (blockchainType === core_1.CHAIN_TYPE.SOLANA) {
-                return new solana_adapter_1.SolanaAdapter(rpcs, this.httpClient, this.createLogger?.(`SOLANA_ADAPTER`));
+                return new solana_adapter_1.SolanaAdapter(rpcs, this.params.httpClient, this.params.solanaParams, this.params.createLogger?.(`SOLANA_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.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.BITCOIN && this.httpClient) {
-            return new bitcoin_adapter_1.BitcoinAdapter(this.httpClient, this.createLogger?.(`BTC_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`));
         }
         return null;
     }

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

@@ -3,9 +3,11 @@ 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,6 +5,8 @@ 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];
@@ -20,8 +22,6 @@ 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/utils/web3-types/tron-web3-pure.d.ts

@@ -2,7 +2,6 @@ import { CommonWeb3Pure } from './common-web3-pure';
 import { TronTransactionConfig } from '../models/tron-transaction-config';
 import { TronParameters } from '../models/tron-parameters';
 import { TronWeb3PrimitiveType, Web3PrimitiveType } from '../models/primitive-types';
-import { FunctionFragment } from 'tronweb/src/types/ABI';
 import { AbiItem } from '../models/abi-types';
 export declare class TronWeb3Pure extends CommonWeb3Pure {
     constructor();
@@ -16,7 +15,7 @@ export declare class TronWeb3Pure extends CommonWeb3Pure {
      * @param methodArguments Parameters to encode.
      * @returns An ABI encoded function call. Means function signature + parameters.
      */
-    static encodeFunctionCall(contractAbi: FunctionFragment[], methodName: string, methodArguments: unknown[]): string;
+    static encodeFunctionCall(contractAbi: any[], methodName: string, methodArguments: unknown[]): string;
     static encodeMethodSignature(methodSignature: string, parameters: TronParameters): string;
     /**
      * Decodes method result using its JSON interface object and given parameters.
@@ -24,7 +23,7 @@ export declare class TronWeb3Pure extends CommonWeb3Pure {
      * @param response Bytes code returned after method call.
      * @returns Parsed method output.
      */
-    static decodeMethodOutput(outputAbi: FunctionFragment[], response: string): Web3PrimitiveType;
+    static decodeMethodOutput(outputAbi: any[], response: string): Web3PrimitiveType;
     private static flattenTypesToString;
     private static flattenTypesToArray;
     private static flattenParameters;