@cryptorubic/web3 0.14.0-alpha.solana-gas.12 → 1.0.0-alpha.no-sdk.1

package/src/lib/adapter/adapters/{utils → adapter-ton/services}/ton-api.service.js

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

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

@@ -0,0 +1,6 @@
+import { TonClient } from '@ton/ton';
+export declare class TonClientInstance {
+    private static instance;
+    private constructor();
+    static getInstance(): TonClient;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonClientInstance = void 0;
+const ton_1 = require("@ton/ton");
+class TonClientInstance {
+    constructor() { }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new ton_1.TonClient({
+                endpoint: 'https://x-api.rubic.exchange/toncenter/api/v2/jsonRPC',
+                apiKey: 'sndfje3u4b3fnNSDNFUSDNVSunw345842hrnfd3b4nt4'
+            });
+        }
+        return this.instance;
+    }
+}
+exports.TonClientInstance = TonClientInstance;
+TonClientInstance.instance = null;

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

@@ -0,0 +1,29 @@
+import { BlockchainName, HttpClient, ICustomLogger, PriceTokenAmount, Token, TokenAmount, TonBlockchainName } from '@cryptorubic/core';
+import { TonClient } from '@ton/ton';
+import { TonApiParseAddressResp } from '../models/tonapi-models';
+import { TonAdapterConfig } from '../models/ton-adapter-config';
+import BigNumber from 'bignumber.js';
+import { AbstractAdapter } from '../common/abstract-adapter';
+import { TonConnectUI } from '@tonconnect/ui';
+import { TonSendTxParams } from './models/ton-send-tx-params';
+import { AbstractAdapterClient } from '../common/client/abstract-adapter-client';
+import { RubicAppAdaptersFactoryParams } from '../../constants/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: AbstractAdapterClient<TonConnectUI, TonSendTxParams, string>;
+    private readonly tonApi;
+    constructor(httpClient: HttpClient, config: TonAdapterConfig, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    multicallContractsMethods<Output extends Web3PrimitiveType>(): Promise<ContractMulticallResponse<Output>[][]>;
+    getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        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/{ton-adapter.js → adapter-ton/ton-adapter.js}

@@ -2,18 +2,51 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TonAdapter = void 0;
 const core_1 = require("@cryptorubic/core");
-const ton_api_service_1 = require("./utils/ton-api.service");
+const ton_api_service_1 = require("./services/ton-api.service");
 const ton_1 = require("@ton/ton");
 const bignumber_js_1 = require("bignumber.js");
-const abstract_adapter_1 = require("./abstract-adapter");
-const web3_pure_1 = require("../../utils/web3-pure");
+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 {
-    tonApi;
-    tonClient;
-    constructor(httpClient, config, logger) {
+    constructor(httpClient, config, logger, rubicAppParams) {
         super(core_1.BLOCKCHAIN_NAME.TON, logger);
         this.tonApi = new ton_api_service_1.TonApiService(httpClient, config.tonApiConfig, logger);
-        this.tonClient = new ton_1.TonClient(config.tonClientConfig);
+        this.client = new ton_adapter_client_1.TonAdapterClient(this.tonApi, config, httpClient, logger, rubicAppParams);
+    }
+    async getTokensBalances(userAddress, tokensAddresses) {
+        const tokensWithBalance = await this.tonApi.fetchAllNonNullableTokensInfoForWallet(userAddress);
+        const nativeIndex = tokensAddresses.findIndex((tokenAddress) => web3_pure_1.Web3Pure.isNativeAddress('TON', tokenAddress));
+        if (!tokensWithBalance.length && nativeIndex === -1) {
+            return [];
+        }
+        const balances = tokensAddresses
+            .filter((tokenAddress) => !web3_pure_1.Web3Pure.isNativeAddress('TON', tokenAddress))
+            .map((address) => {
+            const tokenWithBalance = tokensWithBalance.find((token) => token.jetton.address.toLowerCase() === ton_1.Address.parse(address).toRawString().toLowerCase());
+            if (tokenWithBalance) {
+                return new bignumber_js_1.default(tokenWithBalance.balance);
+            }
+            return new bignumber_js_1.default(0);
+        });
+        if (nativeIndex !== -1) {
+            const acountInfo = await this.tonApi.fetchAccountInfo(userAddress);
+            const nativeBalance = new bignumber_js_1.default(acountInfo.balance);
+            balances.splice(nativeIndex, 0, nativeBalance);
+        }
+        return balances;
+    }
+    multicallContractsMethods() {
+        throw new Error('Method not implemented.');
+    }
+    async getBlockNumber() {
+        try {
+            const block = await this.tonApi.fetchLastBlockInfo();
+            return block.seqno;
+        }
+        catch {
+            return 0;
+        }
     }
     async callForTokensInfo(tokenAddresses) {
         const info = await Promise.all(tokenAddresses.map((address) => {
@@ -43,12 +76,6 @@ class TonAdapter extends abstract_adapter_1.AbstractAdapter {
     async getAllFormatsOfAddress(walletAddress) {
         return this.tonApi.getAllFormatsOfAddress(walletAddress);
     }
-    async getWalletAddress(address, contractAddress) {
-        const addressResult = await this.tonClient.runMethod(contractAddress, 'get_wallet_address', [
-            { cell: (0, ton_1.beginCell)().storeAddress(address).endCell(), type: 'slice' }
-        ]);
-        return addressResult.stack.readAddress();
-    }
     async checkEnoughBalance(token, walletAddress) {
         const weiBalance = await this.getBalance(walletAddress, token.address);
         const balance = core_1.Token.fromWei(weiBalance, token.decimals);
@@ -61,42 +88,5 @@ class TonAdapter extends abstract_adapter_1.AbstractAdapter {
             : (await this.tonApi.fetchTokenInfoForWallet(walletAddress, tokenAddress)).balance;
         return new bignumber_js_1.default(tokenBalance || 0);
     }
-    getTransferEncodedConfig(tokenAddress, walletAddress, receiver, amount) {
-        if ((0, core_1.compareAddresses)(core_1.nativeTokensList.TON.address, tokenAddress)) {
-            return this.getTransferNativeConfig(receiver, amount);
-        }
-        return this.getTransferJettonConfig(tokenAddress, walletAddress, receiver, amount);
-    }
-    async getTransferNativeConfig(receiver, amount) {
-        const transferAmount = BigInt(amount);
-        const encodeConfig = {
-            address: receiver,
-            amount: transferAmount.toString()
-        };
-        return encodeConfig;
-    }
-    async getTransferJettonConfig(tokenAddress, walletAddress, receiver, amount) {
-        const fromAddress = ton_1.Address.parse(walletAddress);
-        const contractAddress = ton_1.Address.parse(tokenAddress);
-        const transferAmount = BigInt(amount);
-        const receiverAddress = ton_1.Address.parse(receiver);
-        const jettonWalletAddress = await this.getWalletAddress(fromAddress, contractAddress);
-        const body = (0, ton_1.beginCell)()
-            .storeUint(0xf8a7ea5, 32)
-            .storeUint(0, 64)
-            .storeCoins(transferAmount)
-            .storeAddress(receiverAddress)
-            .storeAddress(receiverAddress)
-            .storeBit(0)
-            .storeCoins((0, ton_1.toNano)('0.02'))
-            .storeBit(0)
-            .endCell();
-        const encodeConfig = {
-            address: jettonWalletAddress.toRawString(),
-            amount: (0, ton_1.toNano)('0.05').toString(),
-            payload: body.toBoc().toString('base64')
-        };
-        return encodeConfig;
-    }
 }
 exports.TonAdapter = TonAdapter;

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

@@ -0,0 +1,27 @@
+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 { 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';
+export declare class TronAdapterClient extends AbstractAdapterClient<TronWeb, TronSendTxParams, string> implements ApproveAdapterClient<TronTransactionConfig> {
+    private readonly tronAdapter;
+    constructor(tronAdapter: TronAdapter, httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    getBlockchainName(): Promise<BlockchainName>;
+    getAllowance(fromTokenAddress: string, walletAddress: string, spender: string): Promise<AllowanceInfo>;
+    needApprove(from: TokenAmount, walletAddress: string, spender: string): Promise<boolean>;
+    approve(fromAddress: string, tokenAddress: string, spenderAddress: string, amount?: string): Promise<string>;
+    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): TronTransactionConfig;
+    getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+    /**
+     * Gets mined transaction info.
+     * @param hash Transaction hash.
+     */
+    private getTransactionInfo;
+    sendTransaction(params: TronSendTxParams): Promise<string>;
+    trySendTransaction(params: TronSendTxParams): Promise<string>;
+}

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TronAdapterClient = void 0;
+const bignumber_js_1 = require("bignumber.js");
+const abstract_adapter_client_1 = require("../../common/client/abstract-adapter-client");
+const core_1 = require("@cryptorubic/core");
+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");
+class TronAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
+    constructor(tronAdapter, httpClient, logger, rubicAppParams) {
+        super(httpClient, logger, rubicAppParams);
+        this.tronAdapter = tronAdapter;
+    }
+    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])
+        ]);
+        const allowanceWeiBN = new bignumber_js_1.default(allowance);
+        const allowanceNonWei = core_1.Token.fromWei(allowanceWeiBN, Number(decimals));
+        return { allowanceNonWei, allowanceWei: allowanceWeiBN };
+    }
+    async needApprove(from, walletAddress, spender) {
+        if (from.isNative)
+            return false;
+        const { allowanceWei } = await this.getAllowance(from.address, walletAddress, spender);
+        return allowanceWei.lt(from.weiAmount);
+    }
+    async approve(fromAddress, tokenAddress, spenderAddress, amount) {
+        const config = this.encodeApprove(tokenAddress, spenderAddress, amount);
+        return this.tronAdapter.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();
+        return tron_adapter_1.TronAdapter.encodeMethodCall(tokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'approve', [
+            { type: 'address', value: spenderAddress },
+            { type: 'uint256', value: amountWei }
+        ]);
+    }
+    async getTransactionStatus(srcTxHash) {
+        const txReceipt = await this.getTransactionInfo(srcTxHash);
+        if (txReceipt?.receipt) {
+            if (txReceipt.result === 'FAILED') {
+                return tx_status_1.TX_STATUS.FAIL;
+            }
+            return tx_status_1.TX_STATUS.SUCCESS;
+        }
+        return tx_status_1.TX_STATUS.PENDING;
+    }
+    /**
+     * Gets mined transaction info.
+     * @param hash Transaction hash.
+     */
+    async getTransactionInfo(hash) {
+        return this.tronAdapter.public.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);
+            if (params.txOptions.onTransactionHash) {
+                params.txOptions.onTransactionHash(receipt.transaction.txID);
+            }
+            return receipt.transaction.txID;
+        }
+        catch (err) {
+            console.error('Method execution error: ', err);
+            throw (0, parse_tron_error_1.parseTronError)(err);
+        }
+    }
+    async trySendTransaction(params) {
+        try {
+            await this.tronAdapter.public.transactionBuilder.estimateEnergy(params.contractAddress, params.methodSignature, {}, params.parameters, this.walletAddress);
+        }
+        catch (err) {
+            const errMessage = typeof err === 'object' ? err.message : err;
+            if (errMessage !== 'this node does not support estimate energy') {
+                throw new Error('Tron transaction simulation error');
+            }
+        }
+        return this.sendTransaction(params);
+    }
+}
+exports.TronAdapterClient = TronAdapterClient;

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

@@ -0,0 +1,13 @@
+import { TronParameters } from 'packages/web3/src/lib/utils/models/tron-parameters';
+import { BasicSendTransactionOptions } from '../../models/basic-transaction-options';
+export interface TronSendTxParams {
+    contractAddress: string;
+    methodSignature: string;
+    parameters: TronParameters;
+    txOptions: TronTransactionOptions;
+}
+export interface TronTransactionOptions extends BasicSendTransactionOptions {
+    feeLimit?: number;
+    callValue?: number;
+    rawParameter?: string;
+}

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

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

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

@@ -1,37 +1,40 @@
 import BigNumber from 'bignumber.js';
-import { AbstractAdapter } from './abstract-adapter';
+import { AbstractAdapter } from '../common/abstract-adapter';
 import { TronWeb } from 'tronweb';
-import { ICustomLogger, PriceTokenAmount, Token, TokenAmount, TronBlockchainName } from '@cryptorubic/core';
-import { TronTransactionConfig } from '../../utils/models/tron-transaction-config';
-import { TronParameters } from '../../utils/models/tron-parameters';
+import { HttpClient, ICustomLogger, PriceTokenAmount, Token, TokenAmount, TronBlockchainName } from '@cryptorubic/core';
+import { TronTransactionConfig } from '../../../utils/models/tron-transaction-config';
+import { TronParameters } from '../../../utils/models/tron-parameters';
 import { Abi } from 'viem';
-import { ApproveAdapter } from './models/approve-adapter';
-import { AllowanceInfo } from './models/common-types';
-import { ContractMulticallResponse } from '../../utils/models/contract-multicall-response';
-import { TronWeb3PrimitiveType } from '../../utils/models/primitive-types';
-import { MethodData } from '../../utils/models/method-data';
-export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> implements ApproveAdapter<TronTransactionConfig> {
+import { ContractMulticallResponse } from '../../../utils/models/contract-multicall-response';
+import { TronWeb3PrimitiveType } from '../../../utils/models/primitive-types';
+import { MethodData } from '../../../utils/models/method-data';
+import { AbstractAdapterClient } from '../common/client/abstract-adapter-client';
+import { TronSendTxParams } from './models/tron-send-tx-params';
+import { RubicAppAdaptersFactoryParams } from '../../constants/models/create-factory-params';
+import { ApproveAdapterClient } from '../models/approve-adapter';
+export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> {
+    readonly client: AbstractAdapterClient<TronWeb, TronSendTxParams, string> & ApproveAdapterClient<TronTransactionConfig>;
     private readonly multicallAddress;
-    needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
-    constructor(rpcList: string[], logger?: ICustomLogger);
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
+    needPreswapAction(): Promise<boolean>;
+    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
     multicallContractsMethods<Output extends TronWeb3PrimitiveType>(contractAbi: any, contractsData: {
         contractAddress: string;
         methodsData: MethodData[];
     }[]): Promise<ContractMulticallResponse<any>[][]>;
+    getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        workchain: number;
+    }>;
+    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
     private multicall;
     read<T>(contractAddress: string, contractAbi: any, methodName: string, methodArguments?: unknown[]): Promise<T>;
     private multicallContractsMethodsByOne;
-    getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token[]>;
     getBalance(userAddress: string, tokenAddress?: string): Promise<BigNumber>;
     getTokenBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
     convertTronAddressToHex(address: string): Promise<string>;
     static encodeMethodCall(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments: TronParameters, callValue?: string, feeLimit?: number): TronTransactionConfig;
     private static flattenTypesToString;
-    needApprove(from: TokenAmount | PriceTokenAmount, walletAddress: string, spender: string): Promise<boolean>;
-    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): TronTransactionConfig;
-    getAllowance(fromTokenAddress: string, walletAddress: string, spender: string): Promise<AllowanceInfo>;
     write(contractAddress: string, methodSignature: string, parameters: TronParameters): Promise<string>;
-    approve(fromAddress: string, tokenAddress: string, spenderAddress: string, amount?: string): Promise<string>;
 }

package/src/lib/adapter/adapters/{tron-adapter.js → adapter-tron/tron-adapter.js}

@@ -2,26 +2,49 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TronAdapter = void 0;
 const bignumber_js_1 = require("bignumber.js");
-const trc_20_contract_abi_1 = require("./constants/trc-20-contract-abi");
-const tron_multicall_abi_1 = require("./constants/tron-multicall-abi");
-const abstract_adapter_1 = require("./abstract-adapter");
+const trc_20_contract_abi_1 = require("../constants/trc-20-contract-abi");
+const tron_multicall_abi_1 = require("../constants/tron-multicall-abi");
+const abstract_adapter_1 = require("../common/abstract-adapter");
 const tronweb_1 = require("tronweb");
 const core_1 = require("@cryptorubic/core");
-const web3_pure_1 = require("../../utils/web3-pure");
-const tron_web3_pure_1 = require("../../utils/web3-types/tron-web3-pure");
+const web3_pure_1 = require("../../../utils/web3-pure");
+const tron_web3_pure_1 = require("../../../utils/web3-types/tron-web3-pure");
+const tron_adapter_client_1 = require("./client/tron-adapter-client");
 class TronAdapter extends abstract_adapter_1.AbstractAdapter {
-    multicallAddress = 'T9ziQU4EBteJzjzMzhHELdhgWFqwzS5Vki';
-    async needPreswapAction(token, contractAddress, walletAddress, amount) {
-        // return this.needApprove()
+    async needPreswapAction() {
         return false;
     }
-    constructor(rpcList, logger) {
+    constructor(rpcList, httpClient, logger, rubicAppParams) {
         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);
     }
-    async checkEnoughBalance(token, walletAddress) {
-        const balance = await this.getBalance(walletAddress, token.address);
-        return balance.gte(token.tokenAmount);
+    async getTokensBalances(userAddress, tokensAddresses) {
+        const indexOfNativeCoin = tokensAddresses.findIndex((address) => web3_pure_1.Web3Pure.isNativeAddress(core_1.CHAIN_TYPE.TRON, address));
+        const promises = [];
+        if (indexOfNativeCoin !== -1) {
+            tokensAddresses.splice(indexOfNativeCoin, 1);
+            promises[1] = this.getBalance(userAddress);
+        }
+        promises[0] = this.multicallContractsMethods(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, tokensAddresses.map((tokenAddress) => ({
+            contractAddress: tokenAddress,
+            methodsData: [
+                {
+                    methodArguments: [userAddress],
+                    methodName: 'balanceOf'
+                }
+            ]
+        })));
+        const results = await Promise.all(promises);
+        const tokensBalances = results[0].map((tokenResults) => {
+            const { success, output } = tokenResults[0];
+            return success ? new bignumber_js_1.default(output) : new bignumber_js_1.default(0);
+        });
+        if (indexOfNativeCoin !== -1) {
+            tokensBalances.splice(indexOfNativeCoin, 0, results[1]);
+        }
+        return tokensBalances;
     }
     async multicallContractsMethods(contractAbi, contractsData) {
         const calls = contractsData.map(({ contractAddress, methodsData }) => {
@@ -52,6 +75,13 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
             return this.multicallContractsMethodsByOne(contractAbi, contractsData);
         }
     }
+    async getBlockNumber() {
+        return (await this.public.trx.getCurrentBlock()).block_header.raw_data.number;
+    }
+    async checkEnoughBalance(token, walletAddress) {
+        const balance = await this.getBalance(walletAddress, token.address);
+        return balance.gte(token.tokenAmount);
+    }
     async multicall(calls) {
         this.public.setAddress(this.multicallAddress);
         const contract = await this.public.contract(tron_multicall_abi_1.TRON_MULTICALL_ABI, this.multicallAddress);
@@ -83,32 +113,6 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
             }));
         }));
     }
-    async getTokensBalances(userAddress, tokensAddresses) {
-        const indexOfNativeCoin = tokensAddresses.findIndex((address) => web3_pure_1.Web3Pure.isNativeAddress(core_1.CHAIN_TYPE.TRON, address));
-        const promises = [];
-        if (indexOfNativeCoin !== -1) {
-            tokensAddresses.splice(indexOfNativeCoin, 1);
-            promises[1] = this.getBalance(userAddress);
-        }
-        promises[0] = this.multicallContractsMethods(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, tokensAddresses.map((tokenAddress) => ({
-            contractAddress: tokenAddress,
-            methodsData: [
-                {
-                    methodArguments: [userAddress],
-                    methodName: 'balanceOf'
-                }
-            ]
-        })));
-        const results = await Promise.all(promises);
-        const tokensBalances = results[0].map((tokenResults) => {
-            const { success, output } = tokenResults[0];
-            return success ? new bignumber_js_1.default(output) : new bignumber_js_1.default(0);
-        });
-        if (indexOfNativeCoin !== -1) {
-            tokensBalances.splice(indexOfNativeCoin, 0, results[1]);
-        }
-        return tokensBalances;
-    }
     async callForTokensInfo(tokenAddresses) {
         const tokenFields = ['decimals', 'symbol', 'name'];
         const nativeTokenIndex = tokenAddresses.findIndex((address) => web3_pure_1.Web3Pure.isNativeAddress(core_1.CHAIN_TYPE.TRON, address));
@@ -195,38 +199,11 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
             return abiInput.type;
         }) || []);
     }
-    async needApprove(from, walletAddress, spender) {
-        if (from.isNative)
-            return false;
-        const { allowanceWei } = await this.getAllowance(from.address, walletAddress, spender);
-        return allowanceWei.lt(from.weiAmount);
-    }
-    encodeApprove(tokenAddress, spenderAddress, amount) {
-        const amountWei = amount ?? new bignumber_js_1.default(2).pow(256).minus(1).toFixed();
-        return tron_web3_pure_1.TronWeb3Pure.encodeMethodCall(tokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'approve', [
-            { type: 'address', value: spenderAddress },
-            { type: 'uint256', value: amountWei }
-        ]);
-    }
-    async getAllowance(fromTokenAddress, walletAddress, spender) {
-        const [contract, decimals, allowance] = await Promise.all([
-            this.public.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));
-        return { allowanceNonWei, allowanceWei: allowanceWeiBN };
-    }
     async write(contractAddress, methodSignature, parameters) {
-        const transaction = await this.wallet.transactionBuilder.triggerSmartContract(contractAddress, methodSignature, {}, parameters, this.walletAddress);
-        const signedTransaction = await this.wallet.trx.sign(transaction.transaction);
-        const receipt = await this.wallet.trx.sendRawTransaction(signedTransaction);
+        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;
     }
-    async approve(fromAddress, tokenAddress, spenderAddress, amount) {
-        const config = this.encodeApprove(tokenAddress, spenderAddress, amount);
-        return this.write(config.to, config.signature, config.arguments);
-    }
 }
 exports.TronAdapter = TronAdapter;

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

@@ -0,0 +1,2 @@
+import { RubicSdkError } from 'packages/web3/src/lib/errors/rubic-sdk.error';
+export declare function parseTronError(err: unknown): RubicSdkError;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTronError = parseTronError;
+const tron_insufficient_native_balance_1 = require("packages/web3/src/lib/errors/blockchain/tron-insufficient-native-balance");
+const tron_transaction_expired_1 = require("packages/web3/src/lib/errors/blockchain/tron-transaction-expired");
+const user_reject_error_1 = require("packages/web3/src/lib/errors/blockchain/user-reject.error");
+const errors_1 = require("../../utils/errors");
+function parseTronError(err) {
+    if (err?.includes?.('Confirmation declined by user')) {
+        throw new user_reject_error_1.UserRejectError();
+    }
+    const message = err?.message;
+    if (message?.includes('balance is not sufficient')) {
+        throw new tron_insufficient_native_balance_1.TronInsufficientNativeBalance();
+    }
+    if (message?.includes('Transaction expired')) {
+        throw new tron_transaction_expired_1.TronTransactionExpired();
+    }
+    return (0, errors_1.parseError)(err);
+}

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

@@ -0,0 +1,48 @@
+import { Abi } from 'viem';
+import BigNumber from 'bignumber.js';
+import { ICustomLogger, Token, TokenAmount, BlockchainName, PriceTokenAmount } from '@cryptorubic/core';
+import { AbstractAdapterClient } from './client/abstract-adapter-client';
+import { SupportedTokenField } from '../models/token-models';
+import { MethodData } from '../models/web3-public-models/method-data';
+import { ContractMulticallResponse } from '../models/web3-public-models/contract-multicall-response';
+import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
+export declare abstract class AbstractAdapter<P, W, B extends BlockchainName, SendTxParams extends object = {}, SendTxResponse = {}> {
+    abstract client: AbstractAdapterClient<W, SendTxParams, SendTxResponse>;
+    protected readonly logger?: ICustomLogger;
+    protected readonly blockchain: B;
+    private _public;
+    protected set public(value: P | null);
+    get public(): P;
+    protected constructor(blockchain: B, logger?: ICustomLogger);
+    abstract getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    abstract checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
+    abstract callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
+    /**
+     * Gets token info by address.
+     * @param tokenAddress Address of token.
+     * @param tokenFields Token's fields to get.
+     */
+    callForTokenInfo(tokenAddress: string, tokenFields?: SupportedTokenField[]): Promise<Token<BlockchainName>>;
+    /**
+     * Uses multicall to make many methods calls in several contracts.
+     * @param contractAbi Target contract abi.
+     * @param contractsData Contract addresses and methods data, containing methods' names and arguments.
+     */
+    abstract multicallContractsMethods<Output extends Web3PrimitiveType>(contractAbi: Abi, contractsData: {
+        contractAddress: string;
+        methodsData: MethodData[];
+    }[]): Promise<ContractMulticallResponse<Output>[][]>;
+    /**
+     * Gets last block number.
+     * @returns Block number.
+     */
+    abstract getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        workchain: number;
+    }>;
+    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;
+}