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

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonAdapter = void 0;
+const core_1 = require("@cryptorubic/core");
+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("../common/abstract-adapter");
+const web3_pure_1 = require("../../../utils/web3-pure");
+const ton_adapter_signer_1 = require("./signer/ton-adapter-signer");
+const tx_status_1 = require("../models/web3-public-models/tx-status");
+class TonAdapter extends abstract_adapter_1.AbstractAdapter {
+    constructor(httpClient, config, logger, clientParams) {
+        super(core_1.BLOCKCHAIN_NAME.TON, logger);
+        this.config = config;
+        this.tonApi = new ton_api_service_1.TonApiService(httpClient, config.tonApiConfig, logger);
+        this.signer = new ton_adapter_signer_1.TonAdapterSigner(this.tonApi, this.publicRef, httpClient, logger, clientParams);
+    }
+    initWeb3Client() {
+        this.public = new ton_1.TonClient(this.config.tonClientConfig);
+    }
+    async read() {
+        throw new Error('Method read is not supported');
+    }
+    async callContractMethod() {
+        throw new Error('Method call is not supported');
+    }
+    async getTransactionStatus(srcTxHash) {
+        const isCompleted = await this.tonApi.checkIsTxCompleted(srcTxHash);
+        if (isCompleted) {
+            return tx_status_1.TX_STATUS.SUCCESS;
+        }
+        return tx_status_1.TX_STATUS.PENDING;
+    }
+    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) => {
+            if (web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.TON, address)) {
+                const nativeToken = core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.TON];
+                return nativeToken;
+            }
+            return this.tonApi.fetchTokenInfo(address);
+        }));
+        if (!info.length)
+            return [];
+        const necessaryInfo = info.map(({ decimals, name, symbol, address }) => new core_1.Token({
+            address,
+            blockchain: core_1.BLOCKCHAIN_NAME.TON,
+            decimals: Number(decimals),
+            name,
+            symbol
+        }));
+        return necessaryInfo;
+    }
+    async getAllFormatsOfAddress(walletAddress) {
+        return this.tonApi.getAllFormatsOfAddress(walletAddress);
+    }
+    async checkEnoughBalance(token, walletAddress) {
+        const weiBalance = await this.getBalance(walletAddress, token.address);
+        const balance = core_1.Token.fromWei(weiBalance, token.decimals);
+        return balance.gte(token.tokenAmount);
+    }
+    async getBalance(walletAddress, tokenAddress) {
+        const isNative = !tokenAddress || web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.TON, tokenAddress);
+        const tokenBalance = isNative
+            ? (await this.tonApi.fetchAccountInfo(walletAddress)).balance
+            : (await this.tonApi.fetchTokenInfoForWallet(walletAddress, tokenAddress)).balance;
+        return new bignumber_js_1.default(tokenBalance || 0);
+    }
+}
+exports.TonAdapter = TonAdapter;

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

@@ -0,0 +1,13 @@
+import { TronParameters } from '../../../../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/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/models/tron-web-provider.js

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

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

@@ -0,0 +1,17 @@
+import { TronWeb } from 'tronweb';
+import { AbstractAdapterSigner } from '../../common/signer/abstract-adapter-signer';
+import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
+import { TronSendTxParams } from '../models/tron-send-tx-params';
+import { TronParameters } from '../../../../utils/models/tron-parameters';
+export declare class TronAdapterSigner extends AbstractAdapterSigner<TronWeb, TronSendTxParams, string> {
+    private readonly publicRef;
+    get publicClient(): TronWeb;
+    constructor(publicRef: {
+        public: TronWeb | null;
+    }, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    write(contractAddress: string, methodSignature: string, parameters: TronParameters): Promise<string>;
+    getBlockchainName(): Promise<BlockchainName>;
+    sendTransaction(params: TronSendTxParams): Promise<string>;
+    trySendTransaction(params: TronSendTxParams): Promise<string>;
+}

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TronAdapterSigner = void 0;
+const abstract_adapter_signer_1 = require("../../common/signer/abstract-adapter-signer");
+const core_1 = require("@cryptorubic/core");
+const parse_tron_error_1 = require("../utils/parse-tron-error");
+class TronAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    get publicClient() {
+        if (!this.publicRef.public) {
+            const msg = `Trying to access undefined publicClient in TronAdapterSigner.`;
+            this.logger?.customLog(msg);
+            throw new Error(msg);
+        }
+        return this.publicRef.public;
+    }
+    constructor(publicRef, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
+        this.publicRef = publicRef;
+    }
+    async write(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);
+        return receipt.transaction.txID;
+    }
+    getBlockchainName() {
+        return Promise.resolve(core_1.BLOCKCHAIN_NAME.TRON);
+    }
+    async sendTransaction(params) {
+        try {
+            const transaction = await this.wallet.transactionBuilder.triggerSmartContract(params.contractAddress, params.methodSignature, params.txOptions, params.parameters, this.walletAddress);
+            const signedTransaction = await this.wallet.trx.sign(transaction.transaction);
+            const receipt = await this.wallet.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.wallet.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.TronAdapterSigner = TronAdapterSigner;

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

@@ -0,0 +1,57 @@
+import BigNumber from 'bignumber.js';
+import { AbstractAdapter } from '../common/abstract-adapter';
+import { TronWeb } from 'tronweb';
+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 { ContractMulticallResponse } from '../../../utils/models/contract-multicall-response';
+import { TronWeb3PrimitiveType, Web3PrimitiveType } from '../../../utils/models/primitive-types';
+import { MethodData } from '../../../utils/models/method-data';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
+import { TronAdapterSigner } from './signer/tron-adapter-signer';
+import { TronTransactionOptions } from './models/tron-send-tx-params';
+import { AllowanceInfo } from '../models/common-types';
+import { ApprovableAdapter } from '../models/approve-adapter';
+import { TxStatus } from '../models/web3-public-models/tx-status';
+export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> implements ApprovableAdapter<TronTransactionConfig> {
+    private readonly rpcList;
+    readonly signer: TronAdapterSigner;
+    private readonly multicallAddress;
+    needPreswapAction(): Promise<boolean>;
+    constructor(rpcList: (string | {
+        fullHost: string;
+    })[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    initWeb3Client(): void;
+    callContractMethod<T extends Web3PrimitiveType = string>(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments?: unknown[]): Promise<T>;
+    getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+    /**
+     * Gets mined transaction info.
+     * @param hash Transaction hash.
+     */
+    private getTransactionInfo;
+    getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    private batchMulticallTokenBalance;
+    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;
+    private multicallContractsMethodsByOne;
+    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;
+    read<T>(contractAddress: string, contractAbi: any, methodName: string, methodArguments?: unknown[]): Promise<T>;
+    private static flattenTypesToString;
+    getAllowance(fromTokenAddress: string, ownerAddress: string, spenderAddress: string): Promise<AllowanceInfo>;
+    needApprove(from: TokenAmount, walletAddress: string, spender: string): Promise<boolean>;
+    approveTokens(tokenAddress: string, spenderAddress: string, amount?: BigNumber | 'infinity', options?: TronTransactionOptions): Promise<string>;
+    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): TronTransactionConfig;
+}

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

@@ -2,26 +2,99 @@
 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_signer_1 = require("./signer/tron-adapter-signer");
+const options_1 = require("../utils/options");
+const parse_tron_error_1 = require("./utils/parse-tron-error");
+const tx_status_1 = require("../models/web3-public-models/tx-status");
 class TronAdapter extends abstract_adapter_1.AbstractAdapter {
-    async needPreswapAction(token, contractAddress, walletAddress, amount) {
-        // return this.needApprove()
+    async needPreswapAction() {
         return false;
     }
-    constructor(rpcList, logger) {
+    constructor(rpcList, httpClient, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.TRON, logger);
+        this.rpcList = rpcList;
         this.multicallAddress = 'T9ziQU4EBteJzjzMzhHELdhgWFqwzS5Vki';
-        this.public = new tronweb_1.TronWeb({ fullHost: rpcList[0] });
+        this.signer = new tron_adapter_signer_1.TronAdapterSigner(this.publicRef, httpClient, logger, clientParams);
     }
-    async checkEnoughBalance(token, walletAddress) {
-        const balance = await this.getBalance(walletAddress, token.address);
-        return balance.gte(token.tokenAmount);
+    initWeb3Client() {
+        const rpc = typeof this.rpcList[0] === 'string' ? this.rpcList[0] : this.rpcList[0].fullHost;
+        this.public = new tronweb_1.TronWeb({ fullHost: rpc });
+    }
+    async callContractMethod(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);
+    }
+    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.public.trx.getTransactionInfo(hash);
+    }
+    async getTokensBalances(userAddress, tokensAddresses) {
+        const indexOfNativeCoin = tokensAddresses.findIndex((tokenAddress) => web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.TRON, tokenAddress));
+        const promises = [];
+        if (indexOfNativeCoin !== -1) {
+            tokensAddresses.splice(indexOfNativeCoin, 1);
+            promises[1] = this.getBalance(userAddress);
+        }
+        promises[0] = this.batchMulticallTokenBalance(userAddress, tokensAddresses, 50);
+        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 batchMulticallTokenBalance(userAddress, tokensAddresses, batchSize) {
+        if (tokensAddresses.length > 100) {
+            const balances = [];
+            for (let i = 0; i < tokensAddresses.length; i += batchSize) {
+                const batchRequest = tokensAddresses.slice(i, i + batchSize);
+                const batchResult = await this.multicallContractsMethods(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, batchRequest.map((tokenAddress) => ({
+                    contractAddress: tokenAddress,
+                    methodsData: [
+                        {
+                            methodName: 'balanceOf',
+                            methodArguments: [userAddress]
+                        }
+                    ]
+                })));
+                balances.push(...batchResult);
+            }
+            return balances;
+        }
+        return this.multicallContractsMethods(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, tokensAddresses.map((tokenAddress) => ({
+            contractAddress: tokenAddress,
+            methodsData: [
+                {
+                    methodName: 'balanceOf',
+                    methodArguments: [userAddress]
+                }
+            ]
+        })));
     }
     async multicallContractsMethods(contractAbi, contractsData) {
         const calls = contractsData.map(({ contractAddress, methodsData }) => {
@@ -48,22 +121,26 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
                 };
             }));
         }
-        catch {
+        catch (err) {
+            this.logger
+                ? this.logger.customError('[TronAdapter_multicallContractsMethods] Error: ', err)
+                : console.debug('[TronAdapter_multicallContractsMethods] Error:', err);
             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);
         // @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) => {
@@ -83,32 +160,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));
@@ -184,6 +235,12 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
             ...(feeLimit && { feeLimit })
         };
     }
+    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);
+    }
     static flattenTypesToString(abiInputs) {
         return (abiInputs?.map((abiInput) => {
             if (abiInput.type === 'tuple' || abiInput.type.includes('tuple')) {
@@ -195,38 +252,46 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
             return abiInput.type;
         }) || []);
     }
+    async getAllowance(fromTokenAddress, ownerAddress, spenderAddress) {
+        const [decimals, allowance] = await Promise.all([
+            this.read(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'decimals'),
+            this.read(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'allowance', [ownerAddress, spenderAddress])
+        ]);
+        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 approveTokens(tokenAddress, spenderAddress, amount = 'infinity', options = {}) {
+        try {
+            const contract = await this.signer.wallet.contract(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, tokenAddress);
+            const rawValue = amount === 'infinity' ? new bignumber_js_1.default(2).pow(256).minus(1) : amount;
+            const transactionHash = await contract.approve(spenderAddress, rawValue.toFixed(0)).send({
+                ...(options.feeLimit && {
+                    feeLimit: (0, options_1.stringifyAmount)(options.feeLimit)
+                })
+            });
+            if (options.onTransactionHash) {
+                options.onTransactionHash(transactionHash);
+            }
+            return transactionHash;
+        }
+        catch (err) {
+            console.error('Approve execution error: ', err);
+            throw (0, parse_tron_error_1.parseTronError)(err);
+        }
+    }
     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', [
+        return TronAdapter.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);
-        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 '../../../../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("../../../../errors/blockchain/tron-insufficient-native-balance");
+const tron_transaction_expired_1 = require("../../../../errors/blockchain/tron-transaction-expired");
+const user_reject_error_1 = require("../../../../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,84 @@
+import { Abi } from 'viem';
+import BigNumber from 'bignumber.js';
+import { ICustomLogger, Token, TokenAmount, BlockchainName } from '@cryptorubic/core';
+import { AbstractAdapterSigner } from './signer/abstract-adapter-signer';
+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';
+import { TxStatus } from '../models/web3-public-models/tx-status';
+export declare abstract class AbstractAdapter<P, W, B extends BlockchainName, SendTxParams extends object = {}, SendTxResponse = {}> {
+    abstract signer: AbstractAdapterSigner<W, SendTxParams, SendTxResponse>;
+    protected readonly logger?: ICustomLogger;
+    readonly blockchain: B;
+    /**
+     * used to pass public pointer in signer constructor
+     */
+    private _publicRef;
+    protected set public(value: P | null);
+    get public(): P;
+    get publicRef(): {
+        public: P | null;
+    };
+    get connected(): boolean;
+    protected constructor(blockchain: B, logger?: ICustomLogger);
+    /**
+     * Used to set this.public property, if it's not set - you can't send rpc requests to blockchain.
+     * Mostly you need to instantiate it at the same time as BlockchainAdapterFactoryService.createAdapter() called.
+     * In rubic-app it's called on wallet connection to prevent unnecessary rpc requests `net_listening` from viem library.
+     */
+    abstract initWeb3Client(): void;
+    /**
+     * Gets account native or token balance in wei.
+     * @param userAddress Wallet address, whose balance you want to find out.
+     * @param tokenAddress Address of the smart-contract corresponding to the token,
+     */
+    abstract getBalance(userAddress: string, tokenAddress?: string): Promise<BigNumber>;
+    abstract getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    abstract checkEnoughBalance(token: TokenAmount, walletAddress: string): Promise<boolean>;
+    abstract callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
+    /**
+     * Calls pure method of smart-contract and returns its output value.
+     * @param contractAddress Address of smart-contract which method is to be executed.
+     * @param contractAbi Abi of smart-contract which method is to be executed.
+     * @param methodName Called method name.
+     * @param methodArguments Method arguments.
+     * @param options Transaction options.
+     */
+    abstract callContractMethod<T extends Web3PrimitiveType = string>(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments?: unknown[], options?: object): Promise<T>;
+    /**
+     * Gets token info by address.
+     * @param tokenAddress Address of token.
+     * @param tokenFields Token's fields to get.
+     */
+    callForTokenInfo(tokenAddress: string): Promise<Token<BlockchainName>>;
+    /**
+     * Checks that user has enough balance.
+     * @param userAddress Wallet address, which contains tokens.
+     * @param token Token to check balance of.
+     * @param requiredAmount Required user balance in Eth units.
+     */
+    checkBalance(token: Token, requiredAmount: BigNumber, userAddress: string): Promise<void | never>;
+    /**
+     * 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>;
+    static getRandomBytes(bytes: number): string;
+    abstract read<T>(...args: unknown[]): Promise<T>;
+    abstract getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+    getSrcTxStatus(blockchain: BlockchainName, srcTxHash: string): Promise<TxStatus>;
+}