@cryptorubic/web3 1.0.0-alpha.no-sdk.7 → 1.0.0-alpha.no-sdk.9

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "1.0.0-alpha.no-sdk.7",
+    "version": "1.0.0-alpha.no-sdk.9",
     "dependencies": {
         "@ethersproject/bignumber": "^5.8.0",
         "@mysten/sui": "^1.24.0",

package/src/index.d.ts

@@ -66,7 +66,7 @@ export * from './lib/adapter/adapters/utils/timeout';
 export * from './lib/adapter/adapters/utils/waitFor';
 export * from './lib/adapter/blockchain-adapter-factory.service';
 export * from './lib/adapter/constants/chain-configs/chain-configs';
-export * from './lib/adapter/constants/models/create-factory-params';
+export * from './lib/adapter/models/create-factory-params';
 export * from './lib/adapter/constants/models/env-type';
 export * from './lib/adapter/constants/models/solana-web3';
 export * from './lib/adapter/constants/models/viem-chain-type';

package/src/index.js

@@ -69,7 +69,7 @@ tslib_1.__exportStar(require("./lib/adapter/adapters/utils/timeout"), exports);
 tslib_1.__exportStar(require("./lib/adapter/adapters/utils/waitFor"), exports);
 tslib_1.__exportStar(require("./lib/adapter/blockchain-adapter-factory.service"), exports);
 tslib_1.__exportStar(require("./lib/adapter/constants/chain-configs/chain-configs"), exports);
-tslib_1.__exportStar(require("./lib/adapter/constants/models/create-factory-params"), exports);
+tslib_1.__exportStar(require("./lib/adapter/models/create-factory-params"), exports);
 tslib_1.__exportStar(require("./lib/adapter/constants/models/env-type"), exports);
 tslib_1.__exportStar(require("./lib/adapter/constants/models/solana-web3"), exports);
 tslib_1.__exportStar(require("./lib/adapter/constants/models/viem-chain-type"), exports);

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

@@ -3,7 +3,7 @@ import BigNumber from 'bignumber.js';
 import { AbstractAdapter } from '../common/abstract-adapter';
 import { BtcWallet } from '../models/btc-wallet-provider';
 import { BasicSendTransactionOptions } from '../models/basic-transaction-options';
-import { RubicAppAdaptersFactoryParams } from '../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
 import { BitcoinAdapterClient } from './client/bitcoin-adapter-client';
 import { Abi } from 'viem';
 import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
@@ -12,7 +12,7 @@ import { MethodData } from '../models/web3-public-models/method-data';
 export declare class BitcoinAdapter extends AbstractAdapter<BtcWallet, BtcWallet, BitcoinBlockchainName> {
     private readonly httpClient;
     readonly client: BitcoinAdapterClient;
-    constructor(httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    constructor(httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
     callContractMethod<T extends Web3PrimitiveType = string>(): Promise<T>;
     getBalance(userAddress: string): Promise<BigNumber>;
     getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
@@ -27,8 +27,6 @@ export declare class BitcoinAdapter extends AbstractAdapter<BtcWallet, BtcWallet
     getPublicKey(userAddress: string): Promise<string | null>;
     checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
-    read<T>(args: unknown): Promise<T>;
-    write(args: unknown): Promise<string>;
     getPublicKeyFromWallet(): Promise<string>;
     transfer(recipient: string, amount: string, fromAddress: string, memo?: string, options?: BasicSendTransactionOptions): Promise<string>;
     sendPsbtTransaction(psbt: string, userAddress: string, inputIndexes: number[], options?: BasicSendTransactionOptions): Promise<string>;

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

@@ -6,10 +6,10 @@ const bignumber_js_1 = require("bignumber.js");
 const abstract_adapter_1 = require("../common/abstract-adapter");
 const bitcoin_adapter_client_1 = require("./client/bitcoin-adapter-client");
 class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
-    constructor(httpClient, logger, rubicAppParams) {
+    constructor(httpClient, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.BITCOIN, logger);
         this.httpClient = httpClient;
-        this.client = new bitcoin_adapter_client_1.BitcoinAdapterClient(httpClient, logger, rubicAppParams);
+        this.client = new bitcoin_adapter_client_1.BitcoinAdapterClient(httpClient, logger, clientParams);
     }
     callContractMethod() {
         throw new Error('Method not implemented.');
@@ -61,12 +61,6 @@ class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
     async callForTokensInfo(tokenAddresses) {
         return [core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.BITCOIN]];
     }
-    read(args) {
-        throw new Error('Not implemented');
-    }
-    write(args) {
-        throw new Error('Not implemented');
-    }
     async getPublicKeyFromWallet() {
         const res = await this.client.clientWallet.request({
             method: 'request_accounts_and_keys',

package/src/lib/adapter/adapters/adapter-bitcoin/client/bitcoin-adapter-client.d.ts

@@ -1,11 +1,13 @@
 import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
-import { RubicAppAdaptersFactoryParams } from '../../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
 import { BitconSendTxParams } from '../models/btc-send-tx-params';
 import { AbstractAdapterClient } from '../../common/client/abstract-adapter-client';
 import { BtcWallet } from '../../models/btc-wallet-provider';
 import { TxStatus } from '../../models/web3-public-models/tx-status';
 export declare class BitcoinAdapterClient extends AbstractAdapterClient<BtcWallet, BitconSendTxParams, string> {
-    constructor(httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    constructor(httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    read<T>(args: unknown): Promise<T>;
+    write(args: unknown): Promise<string>;
     getBlockchainName(): Promise<BlockchainName>;
     getTransactionStatus(txHash: string): Promise<TxStatus>;
     sendTransaction(params: BitconSendTxParams): Promise<string>;

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

@@ -6,8 +6,14 @@ const abstract_adapter_client_1 = require("../../common/client/abstract-adapter-
 const tx_status_1 = require("../../models/web3-public-models/tx-status");
 const waitFor_1 = require("../../utils/waitFor");
 class BitcoinAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
-    constructor(httpClient, logger, rubicAppParams) {
-        super(httpClient, logger, rubicAppParams);
+    constructor(httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
+    }
+    read(args) {
+        throw new Error('Not implemented');
+    }
+    write(args) {
+        throw new Error('Not implemented');
     }
     getBlockchainName() {
         return Promise.resolve(core_1.BLOCKCHAIN_NAME.BITCOIN);

package/src/lib/adapter/adapters/adapter-evm/client/evm-adapter-client.d.ts

@@ -1,18 +1,17 @@
 import { BlockchainName, HttpClient, ICustomLogger, TokenAmount } from '@cryptorubic/core';
-import { RubicAppAdaptersFactoryParams } from '../../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
 import { AbstractAdapterClient } from '../../common/client/abstract-adapter-client';
-import { Abi, TransactionReceipt, WalletActions, WalletClient } from 'viem';
+import { Abi, PublicActions, PublicClient, TransactionReceipt, WalletActions, WalletClient } from 'viem';
 import { EvmSendTxParams, EvmTransactionOptions } from '../models/evm-send-tx-params';
 import BigNumber from 'bignumber.js';
 import { Web3Error } from '../utils/parse-evm-error';
 import { EvmTransactionConfig } from 'packages/web3/src/lib/utils/models/evm-transaction-config';
-import { EvmAdapter } from '../evm-adapter';
 import { TxStatus } from '../../models/web3-public-models/tx-status';
 import { ApproveAdapterClient } from '../../models/approve-adapter';
 import { AllowanceInfo } from '../../models/common-types';
 export declare class EvmAdapterClient extends AbstractAdapterClient<WalletClient & WalletActions, EvmSendTxParams, TransactionReceipt> implements ApproveAdapterClient<EvmTransactionConfig> {
-    private readonly evmAdapter;
-    constructor(evmAdapter: EvmAdapter, httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    private readonly evmPublic;
+    constructor(evmPublic: PublicActions & PublicClient, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
     getBlockchainName(): Promise<BlockchainName | undefined>;
     getAllowance(fromTokenAddress: string, walletAddress: string, spenderAddress: string): Promise<AllowanceInfo>;
     needApprove(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
@@ -21,7 +20,7 @@ export declare class EvmAdapterClient extends AbstractAdapterClient<WalletClient
      * Build encoded approve transaction config.
      * @param tokenAddress Address of the smart-contract corresponding to the token.
      * @param spenderAddress Wallet or contract address to approve.
-     * @param amount Amount of tokens in approval window in spending cap field
+     * @param amount wei amount of tokens in approval window in spending cap field
      * @returns Encoded approve transaction config.
      */
     encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): EvmTransactionConfig;
@@ -77,4 +76,7 @@ export declare class EvmAdapterClient extends AbstractAdapterClient<WalletClient
     private shouldIgnoreError;
     signMessage(message: string): Promise<string>;
     private getChainAndAccount;
+    read<T>(address: string, abi: Abi, method: string, methodArgs?: unknown[]): Promise<T>;
+    writeContract(address: string, abi: Abi, method: string, value?: string, methodArgs?: unknown[]): Promise<string>;
+    write(address: string, to: string, value: string, data: string): Promise<string>;
 }

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EvmAdapterClient = void 0;
 const core_1 = require("@cryptorubic/core");
 const abstract_adapter_client_1 = require("../../common/client/abstract-adapter-client");
+const viem_1 = require("viem");
 const waitForTransactionReceipt_1 = require("viem/_types/actions/public/waitForTransactionReceipt");
 const options_1 = require("../../utils/options");
 const viem_blockchain_mapping_1 = require("../../../constants/viem-blockchain-mapping");
@@ -14,9 +15,9 @@ const rubic_sdk_error_1 = require("packages/web3/src/lib/errors/rubic-sdk.error"
 const evm_adapter_1 = require("../evm-adapter");
 const tx_status_1 = require("../../models/web3-public-models/tx-status");
 class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
-    constructor(evmAdapter, httpClient, logger, rubicAppParams) {
-        super(httpClient, logger, rubicAppParams);
-        this.evmAdapter = evmAdapter;
+    constructor(evmPublic, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
+        this.evmPublic = evmPublic;
     }
     async getBlockchainName() {
         const userChainId = await this.clientWallet.getChainId();
@@ -24,8 +25,8 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
     }
     async getAllowance(fromTokenAddress, walletAddress, spenderAddress) {
         const [decimals, allowance] = await Promise.all([
-            this.evmAdapter.read(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'decimals'),
-            this.evmAdapter.read(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'allowance', [walletAddress, spenderAddress])
+            this.read(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'decimals'),
+            this.read(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'allowance', [walletAddress, spenderAddress])
         ]);
         const allowanceWeiBN = new bignumber_js_1.default(allowance);
         const allowanceNonWei = core_1.Token.fromWei(allowanceWeiBN, Number(decimals));
@@ -43,13 +44,13 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
     }
     async approve(fromAddress, tokenAddress, spenderAddress, amount) {
         const config = this.encodeApprove(tokenAddress, spenderAddress, amount);
-        return this.evmAdapter.write(fromAddress, config.to, config.value, config.data);
+        return this.write(fromAddress, config.to, config.value, config.data);
     }
     /**
      * Build encoded approve transaction config.
      * @param tokenAddress Address of the smart-contract corresponding to the token.
      * @param spenderAddress Wallet or contract address to approve.
-     * @param amount Amount of tokens in approval window in spending cap field
+     * @param amount wei amount of tokens in approval window in spending cap field
      * @returns Encoded approve transaction config.
      */
     encodeApprove(tokenAddress, spenderAddress, amount) {
@@ -62,7 +63,7 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
         };
     }
     async needPermit2Approve(token, permit2Address, walletAddress, spenderAddress) {
-        const res = await this.evmAdapter.read(permit2Address, uni_v3_permit_abi_1.UNI_V3_PERMIT_2_ABI, 'allowance', [
+        const res = await this.read(permit2Address, uni_v3_permit_abi_1.UNI_V3_PERMIT_2_ABI, 'allowance', [
             walletAddress,
             token.address,
             spenderAddress
@@ -96,7 +97,7 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
      * @param hash Transaction hash
      */
     async getTransactionReceipt(hash) {
-        return this.evmAdapter.public.getTransactionReceipt({ hash: hash });
+        return this.evmPublic.getTransactionReceipt({ hash: hash });
     }
     /**
      * Sends Eth in transaction and resolve the promise when the transaction is included in the block.
@@ -144,7 +145,7 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
                 value,
                 ...(params.txOptions.data && { data: params.txOptions.data })
             };
-            const gas = await this.evmAdapter.public.estimateGas(gaslessParams);
+            const gas = await this.evmPublic.estimateGas(gaslessParams);
             const gasfulParams = {
                 ...gaslessParams,
                 ...(0, options_1.getGasOptions)(params.txOptions),
@@ -156,7 +157,7 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
                 gas
             };
             try {
-                await this.evmAdapter.public.estimateGas(gasfulViemParams);
+                await this.evmPublic.estimateGas(gasfulViemParams);
             }
             catch {
                 throw new rubic_sdk_error_1.RubicSdkError('Low native value');
@@ -237,7 +238,7 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
                 }),
                 account: this.walletAddress
             };
-            const gas = await this.evmAdapter.public.estimateContractGas(gaslessParams);
+            const gas = await this.evmPublic.estimateContractGas(gaslessParams);
             const gasfulParams = {
                 ...gaslessParams,
                 ...(0, options_1.getGasOptions)(options),
@@ -249,7 +250,7 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
                 gas
             };
             try {
-                await this.evmAdapter.public.estimateContractGas(gasfulViemParams);
+                await this.evmPublic.estimateContractGas(gasfulViemParams);
             }
             catch {
                 throw new rubic_sdk_error_1.RubicSdkError('Low native value');
@@ -305,5 +306,36 @@ class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
         }
         return { account, chain };
     }
+    async read(address, abi, method, methodArgs = []) {
+        const result = await this.evmPublic.readContract({
+            abi,
+            address: address,
+            args: methodArgs,
+            functionName: method
+        });
+        return result;
+    }
+    async writeContract(address, abi, method, value = '0', methodArgs = []) {
+        const result = await this.clientWallet.writeContract({
+            abi,
+            address: address,
+            account: address,
+            args: methodArgs,
+            functionName: method,
+            chain: this.evmPublic.chain,
+            value: (0, viem_1.parseEther)(value)
+        });
+        return result;
+    }
+    async write(address, to, value, data) {
+        const result = await this.clientWallet.sendTransaction({
+            account: address,
+            to: to,
+            value: (0, viem_1.parseEther)(value),
+            data: data,
+            chain: this.evmPublic.chain
+        });
+        return result;
+    }
 }
 exports.EvmAdapterClient = EvmAdapterClient;

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

@@ -5,7 +5,7 @@ import BigNumber from 'bignumber.js';
 import { EvmAdapterOptions } from '../models/evm-adapter-options';
 import { EvmTransactionConfig } from '../../../utils/models/evm-transaction-config';
 import { EvmAdapterClient } from './client/evm-adapter-client';
-import { RubicAppAdaptersFactoryParams } from '../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
 import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
 import { ContractMulticallResponse } from '../models/web3-public-models/contract-multicall-response';
 import { MethodData } from '../models/web3-public-models/method-data';
@@ -14,7 +14,7 @@ export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicCl
     readonly client: EvmAdapterClient;
     needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
     handlePreswap(contractAddress: string, walletAddress: string, tokenAmount: TokenAmount): Promise<void>;
-    constructor(httpClient: HttpClient, adapterOptions: EvmAdapterOptions, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    constructor(httpClient: HttpClient, adapterOptions: EvmAdapterOptions, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
     callContractMethod<T extends Web3PrimitiveType = string>(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments?: unknown[], options?: {
         from?: string;
         value?: string;
@@ -31,9 +31,6 @@ export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicCl
         workchain: number;
     }>;
     protected createPublicClient(rpcList: string[]): (PublicActions & PublicClient) | null;
-    read<T>(address: string, abi: Abi, method: string, methodArgs?: unknown[]): Promise<T>;
-    writeContract(address: string, abi: Abi, method: string, value?: string, methodArgs?: unknown[]): Promise<string>;
-    write(address: string, to: string, value: string, data: string): Promise<string>;
     multicallByContract<T>(contracts: MulticallParameters, allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
     multicallByAddress<T>(address: string, abi: Abi, method: string, methodArgs?: unknown[][], allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
     static encodeMethodCall(contractAddress: string, contractAbi: Abi, method: string, parameters?: unknown[], value?: string): EvmTransactionConfig;

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

@@ -23,12 +23,12 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
         const fromTokenAddress = isNative && tokenAmount.blockchain === core_1.BLOCKCHAIN_NAME.METIS
             ? '0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000'
             : tokenAmount.blockchain;
-        await this.writeContract(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'approve', '0', [approveAmount]);
+        await this.client.writeContract(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'approve', '0', [approveAmount]);
     }
-    constructor(httpClient, adapterOptions, logger, rubicAppParams) {
+    constructor(httpClient, adapterOptions, logger, clientParams) {
         super(adapterOptions.blockchain, logger);
         this.public = this.createPublicClient(adapterOptions.rpcList);
-        this.client = new evm_adapter_client_1.EvmAdapterClient(this, httpClient, logger, rubicAppParams);
+        this.client = new evm_adapter_client_1.EvmAdapterClient(this.public, httpClient, logger, clientParams);
     }
     async callContractMethod(contractAddress, contractAbi, methodName, methodArguments = [], options = {}) {
         return this.public.readContract({
@@ -124,37 +124,6 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             })
         });
     }
-    async read(address, abi, method, methodArgs = []) {
-        const result = await this.public.readContract({
-            abi,
-            address: address,
-            args: methodArgs,
-            functionName: method
-        });
-        return result;
-    }
-    async writeContract(address, abi, method, value = '0', methodArgs = []) {
-        const result = await this.client.clientWallet.writeContract({
-            abi,
-            address: address,
-            account: address,
-            args: methodArgs,
-            functionName: method,
-            chain: this.public.chain,
-            value: (0, viem_1.parseEther)(value)
-        });
-        return result;
-    }
-    async write(address, to, value, data) {
-        const result = await this.client.clientWallet.sendTransaction({
-            account: address,
-            to: to,
-            value: (0, viem_1.parseEther)(value),
-            data: data,
-            chain: this.public.chain
-        });
-        return result;
-    }
     async multicallByContract(contracts, allowErrors = true) {
         const results = await this.public.multicall(contracts);
         const rpcRequestFail = results.every((result) => result?.status === 'failure');
@@ -295,7 +264,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             });
             return new bignumber_js_1.default(nativeBalance.toString());
         }
-        const tokenBalance = await this.read(tokenAddress, erc20_token_abi_1.erc20TokenAbi, 'balanceOf', [walletAddress]);
+        const tokenBalance = await this.client.read(tokenAddress, erc20_token_abi_1.erc20TokenAbi, 'balanceOf', [walletAddress]);
         return new bignumber_js_1.default(tokenBalance);
     }
     async getTransactionCount(walletAddress) {

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

@@ -1,13 +1,15 @@
 import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
 import { SolanaWeb3 } from '../../../constants/models/solana-web3';
-import { RubicAppAdaptersFactoryParams } from '../../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
 import { SolanaSendTxParams } from '../models/solana-send-tx-params';
 import { Connection } from '@solana/web3.js';
 import { AbstractAdapterClient } from '../../common/client/abstract-adapter-client';
 import { TxStatus } from '../../models/web3-public-models/tx-status';
 export declare class SolanaAdapterClient extends AbstractAdapterClient<SolanaWeb3, SolanaSendTxParams, string> {
     private readonly connection;
-    constructor(connection: Connection, httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    constructor(connection: Connection, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    read<T>(): Promise<T>;
+    write<T>(): Promise<T>;
     getBlockchainName(): Promise<BlockchainName>;
     getTransactionStatus(txHash: string): Promise<TxStatus>;
     sendTransaction(params: SolanaSendTxParams): Promise<string>;

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

@@ -11,10 +11,16 @@ const errors_1 = require("../../utils/errors");
 const abstract_adapter_client_1 = require("../../common/client/abstract-adapter-client");
 const tx_status_1 = require("../../models/web3-public-models/tx-status");
 class SolanaAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
-    constructor(connection, httpClient, logger, rubicAppParams) {
-        super(httpClient, logger, rubicAppParams);
+    constructor(connection, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
         this.connection = connection;
     }
+    async read() {
+        throw new Error('Method read is not supported');
+    }
+    async write() {
+        throw new Error('Method write is not supported');
+    }
     getBlockchainName() {
         return Promise.resolve(core_1.BLOCKCHAIN_NAME.SOLANA);
     }

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

@@ -1,10 +1,9 @@
-import { Abi } from 'viem';
 import { AddressLookupTableAccount, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
 import { HttpClient, ICustomLogger, PriceTokenAmount, SolanaBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
 import BigNumber from 'bignumber.js';
 import { AbstractAdapter } from '../common/abstract-adapter';
 import { SolanaRawInstruction } from '../models/solana-web3-types';
-import { RubicAppAdaptersFactoryParams } from '../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
 import { SolanaWeb3 } from '../../constants/models/solana-web3';
 import { SolanaAdapterClient } from './client/solana-adapter-client';
 import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
@@ -13,7 +12,7 @@ export declare const NATIVE_SOLANA_MINT_ADDRESS = "So111111111111111111111111111
 export declare class SolanaAdapter extends AbstractAdapter<Connection, SolanaWeb3, SolanaBlockchainName> {
     private readonly httpClient;
     readonly client: SolanaAdapterClient;
-    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
     callContractMethod<T extends Web3PrimitiveType = string>(): Promise<T>;
     /**
      * Gets balance of multiple tokens.
@@ -27,8 +26,6 @@ export declare class SolanaAdapter extends AbstractAdapter<Connection, SolanaWeb
         workchain: number;
     }>;
     private createConection;
-    read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
-    write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
     simulateTransaction(_config: object, _from: string): Promise<void>;
     checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
     getBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;

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

@@ -13,11 +13,11 @@ const solana_tokens_service_1 = require("./services/solana-tokens-service");
 const solana_adapter_client_1 = require("./client/solana-adapter-client");
 exports.NATIVE_SOLANA_MINT_ADDRESS = 'So11111111111111111111111111111111111111111';
 class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
-    constructor(rpcList, httpClient, logger, rubicAppParams) {
+    constructor(rpcList, httpClient, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
         this.httpClient = httpClient;
         this.public = this.createConection(rpcList);
-        this.client = new solana_adapter_client_1.SolanaAdapterClient(this.public, httpClient, logger, rubicAppParams);
+        this.client = new solana_adapter_client_1.SolanaAdapterClient(this.public, httpClient, logger, clientParams);
     }
     async callContractMethod() {
         throw new Error('Method call is not supported');
@@ -57,12 +57,6 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
             return new web3_js_1.Connection(rpcList[0], 'confirmed');
         }
     }
-    async read(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method multicall is not supported');
-    }
-    async write(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method multicall is not supported');
-    }
     async simulateTransaction(_config, _from) { }
     async checkEnoughBalance(token, walletAddress) {
         const balance = await this.getBalance(walletAddress, token.address);

package/src/lib/adapter/adapters/adapter-sui/client/sui-adapter-client.d.ts

@@ -1,13 +1,15 @@
 import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
 import { AbstractAdapterClient } from '../../common/client/abstract-adapter-client';
-import { RubicAppAdaptersFactoryParams } from '../../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
 import { SuiSendTxParams } from '../models/sui-send-tx-params';
 import { WalletAdapter } from '@suiet/wallet-sdk';
 import { TxStatus } from '../../models/web3-public-models/tx-status';
 import { ExecuteTransactionBlockParams, SuiClient, SuiTransactionBlockResponse } from '@mysten/sui/dist/cjs/client';
 export declare class SuiAdapterClient extends AbstractAdapterClient<WalletAdapter, SuiSendTxParams, string> {
     private readonly suiClient;
-    constructor(suiClient: SuiClient, httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    constructor(suiClient: SuiClient, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    read<T>(): Promise<T>;
+    write<T>(): Promise<T>;
     getBlockchainName(): Promise<BlockchainName>;
     getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
     sendTransaction(params: SuiSendTxParams): Promise<string>;

package/src/lib/adapter/adapters/adapter-sui/client/sui-adapter-client.js

@@ -7,10 +7,16 @@ const user_reject_error_1 = require("packages/web3/src/lib/errors/blockchain/use
 const parse_evm_error_1 = require("../../adapter-evm/utils/parse-evm-error");
 const tx_status_1 = require("../../models/web3-public-models/tx-status");
 class SuiAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
-    constructor(suiClient, httpClient, logger, rubicAppParams) {
-        super(httpClient, logger, rubicAppParams);
+    constructor(suiClient, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
         this.suiClient = suiClient;
     }
+    async read() {
+        throw new Error('Method read is not supported');
+    }
+    async write() {
+        throw new Error('Method write is not supported');
+    }
     getBlockchainName() {
         return Promise.resolve(core_1.BLOCKCHAIN_NAME.SUI);
     }

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

@@ -5,12 +5,12 @@ import BigNumber from 'bignumber.js';
 import { AbstractAdapter } from '../common/abstract-adapter';
 import { WalletAdapter } from '@suiet/wallet-sdk';
 import { SuiAdapterClient } from './client/sui-adapter-client';
-import { RubicAppAdaptersFactoryParams } from '../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
 import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
 import { ContractMulticallResponse } from '../models/web3-public-models/contract-multicall-response';
 export declare class SuiAdapter extends AbstractAdapter<SuiClient, WalletAdapter, SuiBlockchainName> {
     readonly client: SuiAdapterClient;
-    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
     callContractMethod<T extends Web3PrimitiveType = string>(): Promise<T>;
     getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
     multicallContractsMethods<Output extends Web3PrimitiveType>(): Promise<ContractMulticallResponse<Output>[][]>;
@@ -18,8 +18,6 @@ export declare class SuiAdapter extends AbstractAdapter<SuiClient, WalletAdapter
         blockNumber: number;
         workchain: number;
     }>;
-    read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
-    write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
     multicallByAddress<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[][], _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
     simulateTransaction(_config: object, _from: string): Promise<void>;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<SuiBlockchainName>[]>;

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

@@ -8,10 +8,10 @@ const abstract_adapter_1 = require("../common/abstract-adapter");
 const web3_pure_1 = require("../../../utils/web3-pure");
 const sui_adapter_client_1 = require("./client/sui-adapter-client");
 class SuiAdapter extends abstract_adapter_1.AbstractAdapter {
-    constructor(rpcList, httpClient, logger, rubicAppParams) {
+    constructor(rpcList, httpClient, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.SUI, logger);
         this.public = new client_1.SuiClient({ url: rpcList[0] });
-        this.client = new sui_adapter_client_1.SuiAdapterClient(this.public, httpClient, logger, rubicAppParams);
+        this.client = new sui_adapter_client_1.SuiAdapterClient(this.public, httpClient, logger, clientParams);
     }
     async callContractMethod() {
         throw new Error('Method call is not supported');
@@ -31,12 +31,6 @@ class SuiAdapter extends abstract_adapter_1.AbstractAdapter {
         const stringEpoch = epochInfo.data[0].epoch;
         return Number(stringEpoch);
     }
-    async read(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method read is not supported');
-    }
-    async write(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method write is not supported');
-    }
     async multicallByAddress(_address, _abi, _method, _methodArgs = [], _allowErrors = true) {
         throw new Error('Method multicall is not supported');
     }

package/src/lib/adapter/adapters/adapter-ton/client/ton-adapter-client.d.ts

@@ -1,6 +1,6 @@
 import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
 import { AbstractAdapterClient } from '../../common/client/abstract-adapter-client';
-import { RubicAppAdaptersFactoryParams } from '../../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
 import { TxStatus } from '../../models/web3-public-models/tx-status';
 import { TonSendTxParams } from '../models/ton-send-tx-params';
 import { TonConnectUI } from '@tonconnect/ui';
@@ -12,7 +12,9 @@ import { TonTransactionConfig } from 'packages/web3/src/lib/utils/models/ton-tra
 export declare class TonAdapterClient extends AbstractAdapterClient<TonConnectUI, TonSendTxParams, string> {
     private readonly tonApi;
     private readonly tonClient;
-    constructor(tonApi: TonApiService, config: TonAdapterConfig, httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    constructor(tonApi: TonApiService, config: TonAdapterConfig, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    read<T>(): Promise<T>;
+    write<T>(): Promise<T>;
     getBlockchainName(): Promise<BlockchainName>;
     getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
     sendTransaction(params: TonSendTxParams): Promise<string>;

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

@@ -11,11 +11,17 @@ const core_2 = require("@ton/core");
 const waitFor_1 = require("../../utils/waitFor");
 const ton_1 = require("@ton/ton");
 class TonAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
-    constructor(tonApi, config, httpClient, logger, rubicAppParams) {
-        super(httpClient, logger, rubicAppParams);
+    constructor(tonApi, config, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
         this.tonApi = tonApi;
         this.tonClient = new ton_1.TonClient(config.tonClientConfig);
     }
+    async read() {
+        throw new Error('Method read is not supported');
+    }
+    async write() {
+        throw new Error('Method write is not supported');
+    }
     getBlockchainName() {
         return Promise.resolve(core_1.BLOCKCHAIN_NAME.TON);
     }

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

@@ -6,13 +6,13 @@ import BigNumber from 'bignumber.js';
 import { AbstractAdapter } from '../common/abstract-adapter';
 import { TonConnectUI } from '@tonconnect/ui';
 import { TonAdapterClient } from './client/ton-adapter-client';
-import { RubicAppAdaptersFactoryParams } from '../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
 import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
 import { ContractMulticallResponse } from '../models/web3-public-models/contract-multicall-response';
 export declare class TonAdapter extends AbstractAdapter<TonClient, TonConnectUI, TonBlockchainName> {
     readonly client: TonAdapterClient;
     private readonly tonApi;
-    constructor(httpClient: HttpClient, config: TonAdapterConfig, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    constructor(httpClient: HttpClient, config: TonAdapterConfig, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
     callContractMethod<T extends Web3PrimitiveType = string>(): Promise<T>;
     getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
     multicallContractsMethods<Output extends Web3PrimitiveType>(): Promise<ContractMulticallResponse<Output>[][]>;
@@ -21,8 +21,6 @@ export declare class TonAdapter extends AbstractAdapter<TonClient, TonConnectUI,
         workchain: number;
     }>;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
-    read<T>(args: unknown): Promise<T>;
-    write(args: unknown): Promise<string>;
     getAllFormatsOfAddress(walletAddress: string): Promise<TonApiParseAddressResp>;
     checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
     getBalance(walletAddress: string, tokenAddress?: string): Promise<BigNumber>;

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

@@ -9,10 +9,10 @@ const abstract_adapter_1 = require("../common/abstract-adapter");
 const web3_pure_1 = require("../../../utils/web3-pure");
 const ton_adapter_client_1 = require("./client/ton-adapter-client");
 class TonAdapter extends abstract_adapter_1.AbstractAdapter {
-    constructor(httpClient, config, logger, rubicAppParams) {
+    constructor(httpClient, config, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.TON, logger);
         this.tonApi = new ton_api_service_1.TonApiService(httpClient, config.tonApiConfig, logger);
-        this.client = new ton_adapter_client_1.TonAdapterClient(this.tonApi, config, httpClient, logger, rubicAppParams);
+        this.client = new ton_adapter_client_1.TonAdapterClient(this.tonApi, config, httpClient, logger, clientParams);
     }
     async callContractMethod() {
         throw new Error('Method call is not supported');
@@ -70,12 +70,6 @@ class TonAdapter extends abstract_adapter_1.AbstractAdapter {
         }));
         return necessaryInfo;
     }
-    read(args) {
-        throw new Error('Not implemented');
-    }
-    write(args) {
-        throw new Error('Not implemented');
-    }
     async getAllFormatsOfAddress(walletAddress) {
         return this.tonApi.getAllFormatsOfAddress(walletAddress);
     }

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

@@ -1,16 +1,18 @@
 import { TronWeb } from 'tronweb';
 import { AbstractAdapterClient } from '../../common/client/abstract-adapter-client';
 import { BlockchainName, HttpClient, ICustomLogger, TokenAmount } from '@cryptorubic/core';
-import { RubicAppAdaptersFactoryParams } from '../../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
 import { TronSendTxParams } from '../models/tron-send-tx-params';
 import { TxStatus } from '../../models/web3-public-models/tx-status';
 import { TronTransactionConfig } from 'packages/web3/src/lib/utils/models/tron-transaction-config';
-import { TronAdapter } from '../tron-adapter';
 import { ApproveAdapterClient } from '../../models/approve-adapter';
 import { AllowanceInfo } from '../../models/common-types';
+import { TronParameters } from 'packages/web3/src/lib/utils/models/tron-parameters';
 export declare class TronAdapterClient extends AbstractAdapterClient<TronWeb, TronSendTxParams, string> implements ApproveAdapterClient<TronTransactionConfig> {
-    private readonly tronAdapter;
-    constructor(tronAdapter: TronAdapter, httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    private readonly tronWeb;
+    constructor(tronWeb: TronWeb, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    read<T>(contractAddress: string, contractAbi: any, methodName: string, methodArguments?: unknown[]): Promise<T>;
+    write(contractAddress: string, methodSignature: string, parameters: TronParameters): Promise<string>;
     getBlockchainName(): Promise<BlockchainName>;
     getAllowance(fromTokenAddress: string, walletAddress: string, spender: string): Promise<AllowanceInfo>;
     needApprove(from: TokenAmount, walletAddress: string, spender: string): Promise<boolean>;

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

@@ -8,19 +8,32 @@ const trc_20_contract_abi_1 = require("../../constants/trc-20-contract-abi");
 const tx_status_1 = require("../../models/web3-public-models/tx-status");
 const parse_tron_error_1 = require("../utils/parse-tron-error");
 const tron_adapter_1 = require("../tron-adapter");
+const tron_web3_pure_1 = require("packages/web3/src/lib/utils/web3-types/tron-web3-pure");
 class TronAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
-    constructor(tronAdapter, httpClient, logger, rubicAppParams) {
-        super(httpClient, logger, rubicAppParams);
-        this.tronAdapter = tronAdapter;
+    constructor(tronWeb, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
+        this.tronWeb = tronWeb;
+    }
+    async read(contractAddress, contractAbi, methodName, methodArguments = []) {
+        this.tronWeb.setAddress(contractAddress);
+        const contract = await this.tronWeb.contract(contractAbi, contractAddress);
+        const response = await contract[methodName](...methodArguments).call();
+        return tron_web3_pure_1.TronWeb3Pure.flattenParameterToPrimitive(response);
+    }
+    async write(contractAddress, methodSignature, parameters) {
+        const transaction = await this.clientWallet.transactionBuilder.triggerSmartContract(contractAddress, methodSignature, {}, parameters, this.walletAddress);
+        const signedTransaction = await this.clientWallet.trx.sign(transaction.transaction);
+        const receipt = await this.clientWallet.trx.sendRawTransaction(signedTransaction);
+        return receipt.transaction.txID;
     }
     getBlockchainName() {
         return Promise.resolve(core_1.BLOCKCHAIN_NAME.TRON);
     }
     async getAllowance(fromTokenAddress, walletAddress, spender) {
         const [contract, decimals, allowance] = await Promise.all([
-            this.tronAdapter.public.contract(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, fromTokenAddress),
-            this.tronAdapter.read(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'decimals'),
-            this.tronAdapter.read(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'allowance', [spender])
+            this.tronWeb.contract(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, fromTokenAddress),
+            this.read(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'decimals'),
+            this.read(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'allowance', [spender])
         ]);
         const allowanceWeiBN = new bignumber_js_1.default(allowance);
         const allowanceNonWei = core_1.Token.fromWei(allowanceWeiBN, Number(decimals));
@@ -34,7 +47,7 @@ class TronAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient
     }
     async approve(fromAddress, tokenAddress, spenderAddress, amount) {
         const config = this.encodeApprove(tokenAddress, spenderAddress, amount);
-        return this.tronAdapter.write(config.to, config.signature, config.arguments);
+        return this.write(config.to, config.signature, config.arguments);
     }
     encodeApprove(tokenAddress, spenderAddress, amount) {
         const amountWei = amount ?? new bignumber_js_1.default(2).pow(256).minus(1).toFixed();
@@ -58,13 +71,13 @@ class TronAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient
      * @param hash Transaction hash.
      */
     async getTransactionInfo(hash) {
-        return this.tronAdapter.public.trx.getTransactionInfo(hash);
+        return this.tronWeb.trx.getTransactionInfo(hash);
     }
     async sendTransaction(params) {
         try {
-            const transaction = await this.tronAdapter.public.transactionBuilder.triggerSmartContract(params.contractAddress, params.methodSignature, params.txOptions, params.parameters, this.walletAddress);
-            const signedTransaction = await this.tronAdapter.public.trx.sign(transaction.transaction);
-            const receipt = await this.tronAdapter.public.trx.sendRawTransaction(signedTransaction);
+            const transaction = await this.tronWeb.transactionBuilder.triggerSmartContract(params.contractAddress, params.methodSignature, params.txOptions, params.parameters, this.walletAddress);
+            const signedTransaction = await this.tronWeb.trx.sign(transaction.transaction);
+            const receipt = await this.tronWeb.trx.sendRawTransaction(signedTransaction);
             if (params.txOptions.onTransactionHash) {
                 params.txOptions.onTransactionHash(receipt.transaction.txID);
             }
@@ -77,7 +90,7 @@ class TronAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient
     }
     async trySendTransaction(params) {
         try {
-            await this.tronAdapter.public.transactionBuilder.estimateEnergy(params.contractAddress, params.methodSignature, {}, params.parameters, this.walletAddress);
+            await this.tronWeb.transactionBuilder.estimateEnergy(params.contractAddress, params.methodSignature, {}, params.parameters, this.walletAddress);
         }
         catch (err) {
             const errMessage = typeof err === 'object' ? err.message : err;

package/src/lib/adapter/adapters/adapter-tron/models/tron-web-provider.d.ts

@@ -0,0 +1,4 @@
+export interface TronWebProvider {
+    fullHost: string;
+    headers?: Record<string, string>;
+}

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

@@ -8,13 +8,13 @@ import { Abi } from 'viem';
 import { ContractMulticallResponse } from '../../../utils/models/contract-multicall-response';
 import { TronWeb3PrimitiveType, Web3PrimitiveType } from '../../../utils/models/primitive-types';
 import { MethodData } from '../../../utils/models/method-data';
-import { RubicAppAdaptersFactoryParams } from '../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
 import { TronAdapterClient } from './client/tron-adapter-client';
 export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> {
     readonly client: TronAdapterClient;
     private readonly multicallAddress;
     needPreswapAction(): Promise<boolean>;
-    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
     callContractMethod<T extends Web3PrimitiveType = string>(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments?: unknown[]): Promise<T>;
     getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
     multicallContractsMethods<Output extends TronWeb3PrimitiveType>(contractAbi: any, contractsData: {
@@ -27,7 +27,6 @@ export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronB
     }>;
     checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
     private multicall;
-    read<T>(contractAddress: string, contractAbi: any, methodName: string, methodArguments?: unknown[]): Promise<T>;
     private multicallContractsMethodsByOne;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token[]>;
     getBalance(userAddress: string, tokenAddress?: string): Promise<BigNumber>;
@@ -35,5 +34,4 @@ export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronB
     convertTronAddressToHex(address: string): Promise<string>;
     static encodeMethodCall(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments: TronParameters, callValue?: string, feeLimit?: number): TronTransactionConfig;
     private static flattenTypesToString;
-    write(contractAddress: string, methodSignature: string, parameters: TronParameters): Promise<string>;
 }

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

@@ -14,11 +14,11 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
     async needPreswapAction() {
         return false;
     }
-    constructor(rpcList, httpClient, logger, rubicAppParams) {
+    constructor(rpcList, httpClient, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.TRON, logger);
         this.multicallAddress = 'T9ziQU4EBteJzjzMzhHELdhgWFqwzS5Vki';
         this.public = new tronweb_1.TronWeb({ fullHost: rpcList[0] });
-        this.client = new tron_adapter_client_1.TronAdapterClient(this, httpClient, logger, rubicAppParams);
+        this.client = new tron_adapter_client_1.TronAdapterClient(this.public, httpClient, logger, clientParams);
     }
     async callContractMethod(contractAddress, contractAbi, methodName, methodArguments = []) {
         this.public.setAddress(contractAddress);
@@ -94,17 +94,11 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
         // @ts-ignore
         return contract.aggregateViewCalls(calls).call();
     }
-    async read(contractAddress, contractAbi, methodName, methodArguments = []) {
-        this.public.setAddress(contractAddress);
-        const contract = await this.public.contract(contractAbi, contractAddress);
-        const response = await contract[methodName](...methodArguments).call();
-        return tron_web3_pure_1.TronWeb3Pure.flattenParameterToPrimitive(response);
-    }
     multicallContractsMethodsByOne(contractAbi, contractsData) {
         return Promise.all(contractsData.map((contractData) => {
             return Promise.all(contractData.methodsData.map(async (methodData) => {
                 try {
-                    const output = (await this.read(contractData.contractAddress, contractAbi, methodData.methodName, methodData.methodArguments));
+                    const output = (await this.client.read(contractData.contractAddress, contractAbi, methodData.methodName, methodData.methodArguments));
                     return {
                         output,
                         success: true
@@ -205,11 +199,5 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
             return abiInput.type;
         }) || []);
     }
-    async write(contractAddress, methodSignature, parameters) {
-        const transaction = await this.client.clientWallet.transactionBuilder.triggerSmartContract(contractAddress, methodSignature, {}, parameters, this.client.walletAddress);
-        const signedTransaction = await this.client.clientWallet.trx.sign(transaction.transaction);
-        const receipt = await this.client.clientWallet.trx.sendRawTransaction(signedTransaction);
-        return receipt.transaction.txID;
-    }
 }
 exports.TronAdapter = TronAdapter;

package/src/lib/adapter/adapters/common/abstract-adapter.d.ts

@@ -57,7 +57,5 @@ export declare abstract class AbstractAdapter<P, W, B extends BlockchainName, Se
     }>;
     needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string | BigNumber): Promise<boolean>;
     handlePreswap(contractAddress: string, walletAddress: string, tokenAmount: TokenAmount): Promise<void>;
-    abstract read<T>(...args: unknown[]): Promise<T>;
-    abstract write(...args: unknown[]): Promise<string>;
     static getRandomBytes(bytes: number): string;
 }

package/src/lib/adapter/adapters/common/client/abstract-adapter-client.d.ts

@@ -1,19 +1,21 @@
 import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
-import { RubicAppAdaptersFactoryParams } from '../../../constants/models/create-factory-params';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
 import { TxStatus } from '../../models/web3-public-models/tx-status';
 export declare abstract class AbstractAdapterClient<ClientWallet, SendTxParams, SendTxResponse> {
     protected readonly httpClient: HttpClient;
     protected readonly logger?: ICustomLogger | undefined;
-    protected readonly rubicAppParams?: RubicAppAdaptersFactoryParams | undefined;
+    protected readonly clientParams?: ClientAdaptersFactoryParams | undefined;
     protected get apiUrl(): string;
     private _walletAddress;
     get walletAddress(): string;
     private _clientWallet;
     get clientWallet(): ClientWallet;
-    constructor(httpClient: HttpClient, logger?: ICustomLogger | undefined, rubicAppParams?: RubicAppAdaptersFactoryParams | undefined);
+    constructor(httpClient: HttpClient, logger?: ICustomLogger | undefined, clientParams?: ClientAdaptersFactoryParams | undefined);
     abstract getBlockchainName(): Promise<BlockchainName | undefined>;
     abstract sendTransaction(params: SendTxParams): Promise<SendTxResponse>;
     abstract getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+    abstract read<T>(...args: unknown[]): Promise<T>;
+    abstract write(...args: unknown[]): Promise<string>;
     /**
      * Checks, that selected blockchain in wallet is equal to passed blockchain.
      */

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

@@ -8,11 +8,11 @@ const waitFor_1 = require("../../utils/waitFor");
 const wrong_network_error_1 = require("../../../../errors/swap/wrong-network.error");
 class AbstractAdapterClient {
     get apiUrl() {
-        if (!this.rubicAppParams) {
-            this.logger?.customError('rubicAppParams is not set for apiUrl call.');
-            throw new Error('rubicAppParams is not set for apiUrl call.');
+        if (!this.clientParams) {
+            this.logger?.customError('clientParams is not set for apiUrl call.');
+            throw new Error('clientParams is not set for apiUrl call.');
         }
-        const rubicApiLink = rubic_api_link_mapping_1.rubicApiLinkMapping[this.rubicAppParams.envType];
+        const rubicApiLink = rubic_api_link_mapping_1.rubicApiLinkMapping[this.clientParams.envType];
         return rubicApiLink ? rubicApiLink : 'https://dev1-api-v2.rubic.exchange';
     }
     get walletAddress() {
@@ -21,10 +21,10 @@ class AbstractAdapterClient {
     get clientWallet() {
         return this._clientWallet;
     }
-    constructor(httpClient, logger, rubicAppParams) {
+    constructor(httpClient, logger, clientParams) {
         this.httpClient = httpClient;
         this.logger = logger;
-        this.rubicAppParams = rubicAppParams;
+        this.clientParams = clientParams;
     }
     /**
      * Checks, that selected blockchain in wallet is equal to passed blockchain.

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

@@ -1,25 +1,24 @@
 import { AbstractAdapter } from './adapters/common/abstract-adapter';
 import { WalletProviderCore } 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/adapter-ton/ton-adapter';
-import { TonAdapterConfig } from './adapters/models/ton-adapter-config';
 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 { RubicAppAdaptersFactoryParams } from './constants/models/create-factory-params';
+import { AdapterFactoryParams } from './models/create-factory-params';
 export declare class BlockchainAdapterFactoryService {
     private readonly rpcList;
     private readonly httpClient;
     private readonly createLogger?;
     private readonly tonParams?;
-    private readonly rubicAppParams?;
+    private readonly clientParams?;
     readonly adapterStore: Partial<Record<BlockchainName, AbstractAdapter<unknown, unknown, BlockchainName>>>;
     protected readonly logger?: ICustomLogger;
     private constructor();
     hasAdapterFor(blockchain: BlockchainName): boolean;
-    static createFactory(rpcList: Partial<Record<EvmBlockchainName, string[]>>, httpClient?: HttpClient, tonParams?: TonAdapterConfig, createLogger?: (label: string) => ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams): Promise<BlockchainAdapterFactoryService>;
+    static createFactory(params: AdapterFactoryParams): Promise<BlockchainAdapterFactoryService>;
     getAdapter(blockchain: SolanaBlockchainName): SolanaAdapter;
     getAdapter(blockchain: EvmBlockchainName): EvmAdapter;
     getAdapter(blockchain: TronBlockchainName): TronAdapter;

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

@@ -10,12 +10,12 @@ 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");
 class BlockchainAdapterFactoryService {
-    constructor(rpcList, httpClient, createLogger, tonParams, rubicAppParams) {
+    constructor(rpcList, httpClient, createLogger, tonParams, clientParams) {
         this.rpcList = rpcList;
         this.httpClient = httpClient;
         this.createLogger = createLogger;
         this.tonParams = tonParams;
-        this.rubicAppParams = rubicAppParams;
+        this.clientParams = clientParams;
         this.adapterStore = {};
         this.adapterStore = this.createStorage();
         if (this.createLogger) {
@@ -26,11 +26,11 @@ class BlockchainAdapterFactoryService {
         const adapter = this.adapterStore?.[blockchain];
         return !!adapter;
     }
-    static async createFactory(rpcList, httpClient, tonParams, createLogger, rubicAppParams) {
+    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, resolvedHttpClient, createLogger, tonParams, rubicAppParams);
+        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];
@@ -68,24 +68,24 @@ class BlockchainAdapterFactoryService {
                     return new evm_adapter_1.EvmAdapter(this.httpClient, {
                         blockchain: blockchain,
                         rpcList: rpcs
-                    }, this.createLogger?.(`EVM_ADAPTER_${blockchain}`), this.rubicAppParams);
+                    }, this.createLogger?.(`EVM_ADAPTER_${blockchain}`), this.clientParams);
                 }
             }
             if (blockchainType === core_1.CHAIN_TYPE.TRON) {
-                return new tron_adapter_1.TronAdapter(rpcs, this.httpClient, this.createLogger?.(`TRON_ADAPTER`), this.rubicAppParams);
+                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.rubicAppParams);
+                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.httpClient, this.createLogger?.(`SOLANA_ADAPTER`), this.rubicAppParams);
+                return new solana_adapter_1.SolanaAdapter(rpcs, this.httpClient, this.createLogger?.(`SOLANA_ADAPTER`), this.clientParams);
             }
         }
         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.rubicAppParams);
+            return new ton_adapter_1.TonAdapter(this.httpClient, this.tonParams, this.createLogger?.(`TON_ADAPTER`), this.clientParams);
         }
         if (blockchain === core_1.BLOCKCHAIN_NAME.BITCOIN && this.httpClient) {
-            return new bitcoin_adapter_1.BitcoinAdapter(this.httpClient, this.createLogger?.(`BTC_ADAPTER`), this.rubicAppParams);
+            return new bitcoin_adapter_1.BitcoinAdapter(this.httpClient, this.createLogger?.(`BTC_ADAPTER`), this.clientParams);
         }
         return null;
     }

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

@@ -0,0 +1,15 @@
+import { BitcoinBlockchainName, EvmBlockchainName, HttpClient, ICustomLogger, SolanaBlockchainName, SuiBlockchainName, TonBlockchainName, TronBlockchainName } from '@cryptorubic/core';
+import { EnvType } from '../constants/models/env-type';
+import { TronWebProvider } from '../adapters/adapter-tron/models/tron-web-provider';
+import { TonAdapterConfig } from '../adapters/models/ton-adapter-config';
+export type RpcSupportedBlockhainName = Record<EvmBlockchainName, string[]> & Record<TronBlockchainName, TronWebProvider[]> & Record<SolanaBlockchainName, string[]> & Record<TonBlockchainName, string[]> & Record<BitcoinBlockchainName, string[]> & Record<SuiBlockchainName, string[]>;
+export interface AdapterFactoryParams {
+    rpcList: RpcSupportedBlockhainName;
+    httpClient?: HttpClient;
+    tonParams?: TonAdapterConfig;
+    createLogger?: (label: string) => ICustomLogger;
+    clientParams?: ClientAdaptersFactoryParams;
+}
+export interface ClientAdaptersFactoryParams {
+    envType: EnvType;
+}

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

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

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

@@ -1,8 +0,0 @@
-import { EnvType } from './env-type';
-export interface RubicAppAdaptersFactoryParams {
-    envType: EnvType;
-    /**
-     * solanaWeb3, tronWeb, tonConnectUI, web3 etc...
-     */
-    clientWallet: any;
-}