@cryptorubic/web3 0.15.0-alpha-rub-1045.0 → 1.0.0-alpha-rub-1044.0

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

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmAdapterSigner = void 0;
+const core_1 = require("@cryptorubic/core");
+const bignumber_js_1 = require("bignumber.js");
+const viem_1 = require("viem");
+const actions_1 = require("viem/actions");
+const tx_reverted_in_chain_error_1 = require("../../../../errors/common/tx-reverted-in-chain.error");
+const rubic_sdk_error_1 = require("../../../../errors/rubic-sdk.error");
+const viem_blockchain_mapping_1 = require("../../../constants/viem-blockchain-mapping");
+const abstract_adapter_signer_1 = require("../../common/signer/abstract-adapter-signer");
+const options_1 = require("../../utils/options");
+const parse_evm_error_1 = require("../utils/parse-evm-error");
+class EvmAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    get publicClient() {
+        if (!this.publicRef.public) {
+            const msg = `Trying to access undefined publicClient in EvmAdapterSigner.`;
+            this.logger?.customLog(msg);
+            throw new Error(msg);
+        }
+        return this.publicRef.public;
+    }
+    constructor(publicRef, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
+        this.publicRef = publicRef;
+    }
+    async getBlockchainName() {
+        const userChainId = await this.wallet.getChainId();
+        return core_1.BlockchainsInfo.getBlockchainNameById(userChainId);
+    }
+    /**
+     * Sends Eth in transaction and resolve the promise when the transaction is included in the block.
+     * @param toAddress Eth receiver address.
+     * @param [options] Additional options.
+     * @returns Transaction receipt.
+     */
+    async sendTransaction(params) {
+        try {
+            const to = params.txOptions.to;
+            const value = BigInt(params.txOptions.value?.toString() || '0');
+            const { account, chain } = await this.getChainAndAccount();
+            const viemParams = {
+                value,
+                account,
+                to,
+                ...(0, options_1.getViemGasOptions)(params.txOptions),
+                ...(params.txOptions.data && { data: params.txOptions.data }),
+                ...(params.txOptions.gas && { gas: BigInt(params.txOptions.gas) }),
+                chain
+            };
+            const hash = await this.wallet.sendTransaction(viemParams);
+            params.txOptions?.onTransactionHash?.(hash);
+            return (0, actions_1.waitForTransactionReceipt)(this.wallet, { hash });
+        }
+        catch (err) {
+            console.error('Send transaction error', err);
+            throw err;
+        }
+    }
+    /**
+     * Tries to send Eth in transaction and resolve the promise when the transaction is included in the block or rejects the error.
+     * @param toAddress Eth receiver address.
+     * @param [options] Additional options.
+     * @returns Transaction receipt.
+     */
+    async trySendTransaction(params) {
+        try {
+            const to = params.txOptions.to;
+            const value = BigInt(params.txOptions.value?.toString() || '0');
+            const gaslessParams = {
+                account: this.walletAddress,
+                to,
+                value,
+                ...(params.txOptions.data && { data: params.txOptions.data })
+            };
+            const gas = params.txOptions.gas ? BigInt(params.txOptions.gas) : await this.publicClient.estimateGas(gaslessParams);
+            const calculatedGas = params.txOptions.gasLimitRatio
+                ? BigInt(new bignumber_js_1.default(gas.toString()).multipliedBy(params.txOptions.gasLimitRatio).toFixed(0))
+                : gas;
+            const gasfulParams = {
+                ...gaslessParams,
+                ...(0, options_1.getGasOptions)(params.txOptions),
+                gas: calculatedGas.toString()
+            };
+            const gasfulViemParams = {
+                ...gaslessParams,
+                ...(0, options_1.getViemGasOptions)(params.txOptions),
+                gas: calculatedGas
+            };
+            try {
+                await this.publicClient.estimateGas(gasfulViemParams);
+            }
+            catch {
+                throw new rubic_sdk_error_1.RubicSdkError('Low native value');
+            }
+            const sendParams = {
+                ...gasfulParams,
+                ...(params.txOptions.onTransactionHash && {
+                    onTransactionHash: params.txOptions.onTransactionHash,
+                    gasPriceOptions: params.txOptions?.gasPriceOptions
+                })
+            };
+            const receipt = await this.sendTransaction({ txOptions: sendParams });
+            if (receipt.status !== 'success') {
+                throw new tx_reverted_in_chain_error_1.TxRevertedInBlockchainError();
+            }
+            return receipt;
+        }
+        catch (err) {
+            console.debug('Call tokens transfer error', err);
+            const shouldIgnore = await this.shouldIgnoreError(err);
+            if (shouldIgnore) {
+                return this.sendTransaction(params);
+            }
+            throw (0, parse_evm_error_1.parseEvmError)(err);
+        }
+    }
+    /**
+     * Executes method of smart-contract and resolve the promise when the transaction is included in the block.
+     * @param contractAddress Address of smart-contract which method is to be executed.
+     * @param contractAbi Abi of smart-contract which method is to be executed.
+     * @param methodName Method name to execute.
+     * @param methodArguments Method arguments.
+     * @param [options] Additional options.
+     * @returns Smart-contract method returned value.
+     */
+    async executeContractMethod(contractAddress, contractAbi, methodName, methodArguments, options = {}) {
+        try {
+            const { account, chain } = await this.getChainAndAccount();
+            const sendParams = {
+                address: contractAddress,
+                abi: contractAbi,
+                functionName: methodName,
+                args: methodArguments,
+                ...(options.value && {
+                    value: BigInt(options.value?.toString())
+                }),
+                ...(options.gas && {
+                    gas: BigInt(options.gas)
+                }),
+                ...(0, options_1.getViemGasOptions)(options),
+                account: account,
+                chain: chain
+            };
+            const hash = await this.wallet.writeContract(sendParams);
+            options?.onTransactionHash?.(hash);
+            return (0, actions_1.waitForTransactionReceipt)(this.wallet, { hash });
+        }
+        catch (err) {
+            console.error(`Method execution error. ${err}`);
+            throw (0, parse_evm_error_1.parseEvmError)(err);
+        }
+    }
+    /**
+     * Tries to execute method of smart-contract and resolve the promise when the transaction is included in the block or rejects the error.
+     * @param contractAddress Address of smart-contract which method is to be executed.
+     * @param contractAbi Abi of smart-contract which method is to be executed.
+     * @param methodName Method name to execute.
+     * @param methodArguments Method arguments.
+     * @param [options] Additional options.
+     * @param allowError Check error and decides to execute contact if error is allowed.
+     */
+    async tryExecuteContractMethod(contractAddress, contractAbi, methodName, methodArguments, options = {}, allowError) {
+        try {
+            const gaslessParams = {
+                address: contractAddress,
+                abi: contractAbi,
+                functionName: methodName,
+                args: methodArguments,
+                ...(options.value && {
+                    value: BigInt(options.value?.toString())
+                }),
+                account: this.walletAddress
+            };
+            const gas = await this.publicClient.estimateContractGas(gaslessParams);
+            const gasfulParams = {
+                ...gaslessParams,
+                ...(0, options_1.getGasOptions)(options),
+                gas: gas.toString()
+            };
+            const gasfulViemParams = {
+                ...gaslessParams,
+                ...(0, options_1.getViemGasOptions)(options),
+                gas
+            };
+            try {
+                await this.publicClient.estimateContractGas(gasfulViemParams);
+            }
+            catch {
+                throw new rubic_sdk_error_1.RubicSdkError('Low native value');
+            }
+            const recepit = await this.executeContractMethod(contractAddress, contractAbi, methodName, methodArguments, {
+                ...gasfulParams,
+                ...(options.onTransactionHash && {
+                    onTransactionHash: options.onTransactionHash,
+                    gasPriceOptions: options?.gasPriceOptions
+                })
+            });
+            return recepit;
+        }
+        catch (err) {
+            if ((allowError && allowError(err)) || (await this.shouldIgnoreError(err))) {
+                return this.executeContractMethod(contractAddress, contractAbi, methodName, methodArguments, options);
+            }
+            console.error('Method execution error: ', err);
+            throw (0, parse_evm_error_1.parseEvmError)(err);
+        }
+    }
+    async shouldIgnoreError(error) {
+        if (error.message === 'Low native value' && (await this.getBlockchainName()) === core_1.BLOCKCHAIN_NAME.MANTLE) {
+            return true;
+        }
+        const ignoreCallErrors = [
+            'STF',
+            'execution reverted: ERC20: transfer amount exceeds allowance',
+            'Anyswaperc20: request exceed allowance',
+            'gas required exceeds allowance',
+            'execution reverted: SafeERC20: low-level call failed'
+        ];
+        const test = ignoreCallErrors.some((err) => error?.message?.toLowerCase().includes(err.toLowerCase()));
+        console.debug(test);
+        return test;
+    }
+    async signMessage(message) {
+        return this.wallet.signMessage({
+            account: this.walletAddress,
+            message: message
+        });
+    }
+    async getChainAndAccount() {
+        const account = this.walletAddress;
+        const chainId = await this.wallet.getChainId();
+        const chainName = core_1.BlockchainsInfo.getBlockchainNameById(chainId);
+        if (!chainName) {
+            throw Error(`Unsupported chain ID: ${chainId}. Please provide a valid EVM blockchain ID`);
+        }
+        const chain = viem_blockchain_mapping_1.viemBlockchainMapping[chainName];
+        if (!chain) {
+            throw Error(`Unsupported chain ID: ${chainId}. Please provide a valid EVM blockchain ID`);
+        }
+        return { account, chain };
+    }
+    async writeContract(address, abi, method, value = '0', methodArgs = []) {
+        const result = await this.wallet.writeContract({
+            abi,
+            address: address,
+            account: address,
+            args: methodArgs,
+            functionName: method,
+            chain: this.publicClient.chain,
+            value: (0, viem_1.parseEther)(value)
+        });
+        return result;
+    }
+    async write(address, to, value, data, options = {}) {
+        const result = await this.wallet.sendTransaction({
+            account: address,
+            to: to,
+            value: (0, viem_1.parseEther)(value),
+            data: data,
+            chain: this.publicClient.chain,
+            ...(options.gas && { gas: BigInt(options.gas) }),
+            ...(0, options_1.getViemGasOptions)(options)
+        });
+        return result;
+    }
+}
+exports.EvmAdapterSigner = EvmAdapterSigner;

package/src/lib/adapter/adapters/adapter-evm/utils/parse-evm-error.d.ts

@@ -0,0 +1,12 @@
+import { RubicSdkError } from '../../../../errors/rubic-sdk.error';
+/**
+ * Type of errors, thrown by web3 methods.
+ */
+export interface Web3Error extends Error {
+    code: number;
+}
+/**
+ * Parses web3 error by its code or message.
+ * @param err Web3 error to parse.
+ */
+export declare function parseEvmError(err: Web3Error): RubicSdkError;

package/src/lib/adapter/adapters/adapter-evm/utils/parse-evm-error.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEvmError = parseEvmError;
+const low_gas_error_1 = require("../../../../errors/blockchain/low-gas.error");
+const transaction_reverted_error_1 = require("../../../../errors/blockchain/transaction-reverted.error");
+const user_reject_error_1 = require("../../../../errors/blockchain/user-reject.error");
+const insufficient_funds_gas_price_value_error_1 = require("../../../../errors/cross-chain/insufficient-funds-gas-price-value.error");
+const rubic_sdk_error_1 = require("../../../../errors/rubic-sdk.error");
+const failed_to_check_for_transaction_receipt_error_1 = require("../../../../errors/swap/failed-to-check-for-transaction-receipt.error");
+const low_slippage_error_1 = require("../../../../errors/swap/low-slippage.error");
+const proxy_hash_errors_1 = require("../constants/proxy-hash-errors");
+const low_slippage_deflationary_token_error_1 = require("../../../../errors/swap/low-slippage-deflationary-token.error");
+const errors_1 = require("../../utils/errors");
+/**
+ * Parses web3 error by its code or message.
+ * @param err Web3 error to parse.
+ */
+function parseEvmError(err) {
+    if (err.message.includes('Transaction has been reverted by the EVM')) {
+        return new transaction_reverted_error_1.TransactionRevertedError();
+    }
+    if (err.message.includes('execution reverted: UNIV3R: min return')) {
+        return new low_slippage_error_1.LowSlippageError();
+    }
+    if (err.message.includes('execution reverted: Address: low-level call with value failed') || err.message.includes('Low native value')) {
+        return new insufficient_funds_gas_price_value_error_1.InsufficientFundsGasPriceValueError();
+    }
+    if (err.message.includes('Failed to check for transaction receipt')) {
+        return new failed_to_check_for_transaction_receipt_error_1.FailedToCheckForTransactionReceiptError();
+    }
+    if (err.code === -32603) {
+        return new low_gas_error_1.LowGasError();
+    }
+    if (err.code === 4001 ||
+        err.message.toLowerCase().includes('user denied transaction signature') ||
+        err.message.toLowerCase().includes('user rejected the request')) {
+        return new user_reject_error_1.UserRejectError();
+    }
+    try {
+        const error = tryParseProxyError(err);
+        if (error) {
+            return error;
+        }
+        if (err.message.includes('0x6c544f')) {
+            return new insufficient_funds_gas_price_value_error_1.InsufficientFundsGasPriceValueError();
+        }
+        if (err.message.includes('0xf32bec2f') ||
+            err.message.includes('execution reverted: Received amount of tokens are less then expected') ||
+            err.message.includes('0x275c273c')) {
+            return new low_slippage_deflationary_token_error_1.LowSlippageDeflationaryTokenError();
+        }
+        const errorMessage = JSON.parse(err.message.slice(24)).message;
+        if (errorMessage) {
+            return new Error(errorMessage);
+        }
+    }
+    catch {
+        /* empty */
+    }
+    return (0, errors_1.parseError)(err);
+}
+function tryParseProxyError(err) {
+    if ('data' in err) {
+        const error = proxy_hash_errors_1.proxyHashErrors.find((error) => error.hash === err.data);
+        if (error) {
+            return new rubic_sdk_error_1.RubicSdkError(error.text);
+        }
+    }
+    return undefined;
+}

package/src/lib/adapter/adapters/adapter-solana/models/solana-send-tx-params.d.ts

@@ -0,0 +1,16 @@
+import { BasicSendTransactionOptions } from '../../models/basic-transaction-options';
+export interface SolanaSendTxParams {
+    txOptions: SolanaTransactionOptions;
+    calculateConsumedParams?: boolean;
+    additionalData?: string[];
+}
+export interface SolanaTransactionOptions extends BasicSendTransactionOptions {
+    /**
+     * Encoded data, which will be executed in transaction.
+     */
+    data?: string;
+    sponsorParams?: {
+        tradeId: string;
+        feePayer: string;
+    };
+}

package/src/lib/adapter/adapters/adapter-solana/models/solana-send-tx-params.js

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

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

@@ -3,7 +3,7 @@ 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("../../utils/timeout");
 class SolanaTokensService {
     constructor(connection, httpClient) {
         this.httpClient = httpClient;
@@ -112,7 +112,7 @@ class SolanaTokensService {
     async getTokensList(tokenAddresses) {
         try {
             const queryParams = tokenAddresses.length > 1 ? { addresses: tokenAddresses.join(',') } : { query: tokenAddresses[0] };
-            const resp = await this.httpClient.get(`${this.newTokensEndpoint}/tokens`, {
+            const resp = await this.httpClient.get(`${this.newTokensEndpoint}/tokens/`, {
                 params: queryParams
             });
             return resp.results.map((t) => ({

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

@@ -0,0 +1,17 @@
+import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { SolanaWeb3 } from '../../../constants/models/solana-web3';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
+import { SolanaSendTxParams } from '../models/solana-send-tx-params';
+import { Connection } from '@solana/web3.js';
+import { AbstractAdapterSigner } from '../../common/signer/abstract-adapter-signer';
+export declare class SolanaAdapterSigner extends AbstractAdapterSigner<SolanaWeb3, SolanaSendTxParams, string> {
+    private readonly publicRef;
+    get publicClient(): Connection;
+    constructor(publicRef: {
+        public: Connection | null;
+    }, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    write<T>(): Promise<T>;
+    getBlockchainName(): Promise<BlockchainName>;
+    sendTransaction(params: SolanaSendTxParams): Promise<string>;
+    private waitForTxConfirmation;
+}

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaAdapterSigner = void 0;
+const core_1 = require("@cryptorubic/core");
+const web3_js_1 = require("@solana/web3.js");
+const waitFor_1 = require("../../utils/waitFor");
+const js_base64_1 = require("js-base64");
+const user_reject_error_1 = require("../../../../errors/blockchain/user-reject.error");
+const errors_1 = require("../../utils/errors");
+const abstract_adapter_signer_1 = require("../../common/signer/abstract-adapter-signer");
+const tx_reverted_in_chain_error_1 = require("../../../../errors/common/tx-reverted-in-chain.error");
+class SolanaAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    get publicClient() {
+        if (!this.publicRef.public) {
+            const msg = `Trying to access undefined publicClient in SolanaAdapterSigner.`;
+            this.logger?.customLog(msg);
+            throw new Error(msg);
+        }
+        return this.publicRef.public;
+    }
+    constructor(publicRef, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
+        this.publicRef = publicRef;
+    }
+    async write() {
+        throw new Error('Method write is not supported');
+    }
+    getBlockchainName() {
+        return Promise.resolve(core_1.BLOCKCHAIN_NAME.SOLANA);
+    }
+    async sendTransaction(params) {
+        try {
+            const decodedData = js_base64_1.Base64.toUint8Array(params.txOptions.data);
+            const tx = web3_js_1.VersionedTransaction.deserialize(decodedData);
+            const signedTx = await this.wallet.signTransaction(tx);
+            const txBase64 = js_base64_1.Base64.fromUint8Array(signedTx.serialize());
+            let signature;
+            if (params.txOptions?.sponsorParams) {
+                const response = await this.httpClient.post(`${this.apiUrl}/api/utility/solana/relay`, {
+                    txBase64,
+                    tradeId: params.txOptions.sponsorParams.tradeId
+                });
+                signature = response.signature;
+            }
+            else {
+                try {
+                    const simulation = await this.publicClient.simulateTransaction(signedTx, {
+                        sigVerify: true,
+                        replaceRecentBlockhash: false
+                    });
+                    console.log(simulation);
+                }
+                catch (err) {
+                    console.log(err);
+                }
+                signature = await this.publicClient.sendRawTransaction(signedTx.serialize(), {
+                    maxRetries: 3,
+                    skipPreflight: false
+                });
+            }
+            params.txOptions.onTransactionHash?.(signature);
+            await this.waitForTxConfirmation(signature);
+            return signature;
+        }
+        catch (err) {
+            console.error(`[SolanaWeb3Private_sendTransaction] Error: ${err}`, { name: err.name, stack: err.stack });
+            if (err.message.includes('User rejected')) {
+                throw new user_reject_error_1.UserRejectError();
+            }
+            throw (0, errors_1.parseError)(err);
+        }
+    }
+    async waitForTxConfirmation(signature) {
+        const deadline = Date.now() + 3 * 60 * 1000;
+        let fetchedTx = null;
+        while (!fetchedTx && Date.now() < deadline) {
+            await (0, waitFor_1.waitFor)(5000);
+            fetchedTx = await this.publicClient.getTransaction(signature, {
+                commitment: 'confirmed',
+                maxSupportedTransactionVersion: 1
+            });
+        }
+        if (!fetchedTx || fetchedTx.meta?.err)
+            throw new tx_reverted_in_chain_error_1.TxRevertedInBlockchainError();
+    }
+}
+exports.SolanaAdapterSigner = SolanaAdapterSigner;

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

@@ -1,28 +1,38 @@
-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';
-export declare const NATIVE_SOLANA_MINT_ADDRESS = "So11111111111111111111111111111111111111111";
-export declare class SolanaAdapter extends AbstractAdapter<Connection, Connection, SolanaBlockchainName> {
+import { AbstractAdapter } from '../common/abstract-adapter';
+import { SolanaRawInstruction } from '../models/solana-web3-types';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
+import { SolanaWeb3 } from '../../constants/models/solana-web3';
+import { SolanaAdapterSigner } from './signer/solana-adapter-signer';
+import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
+import { ContractMulticallResponse } from '../models/web3-public-models/contract-multicall-response';
+import { TxStatus } from '../models/web3-public-models/tx-status';
+export declare class SolanaAdapter extends AbstractAdapter<Connection, SolanaWeb3, SolanaBlockchainName> {
+    private readonly rpcList;
     private readonly httpClient;
-    constructor(rpcList: string[], httpClient: HttpClient, 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>;
-    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: EvmTransactionConfig, _from: string): Promise<void>;
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    getBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
+    readonly signer: SolanaAdapterSigner;
+    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    initWeb3Client(): void;
+    callContractMethod<T extends Web3PrimitiveType = string>(): Promise<T>;
+    read<T>(): Promise<T>;
+    getTransactionStatus(txHash: string): Promise<TxStatus>;
     /**
      * Gets balance of multiple tokens.
      * @param address Wallet address.
      * @param tokensAddresses Tokens addresses.
      */
     getTokensBalances(address: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    multicallContractsMethods<Output extends Web3PrimitiveType>(): Promise<ContractMulticallResponse<Output>[][]>;
+    getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        workchain: number;
+    }>;
+    private createConection;
+    simulateTransaction(_config: object, _from: string): Promise<void>;
+    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
+    getBalance(userAddress: string, tokenAddress?: string): Promise<BigNumber>;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<SolanaBlockchainName>[]>;
     parseRawInstruction(rawInstruction: SolanaRawInstruction[], dataFormat: BufferEncoding): TransactionInstruction[];
     parseLUTAddresses(lookupTableAddresses: string[]): Promise<AddressLookupTableAccount[]>;