@cryptorubic/web3 0.15.0-alpha-stellar.0 → 0.16.3-alpha-2695.0

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

@@ -2,103 +2,67 @@
 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.multicallAddress = 'T9ziQU4EBteJzjzMzhHELdhgWFqwzS5Vki';
-        this.public = new tronweb_1.TronWeb({ fullHost: rpcList[0] });
+        this.rpcList = rpcList;
+        this.clientParams = clientParams;
+        this.multicallAddress = 'TEazPvZwDjDtFeJupyo7QunvnrnUjPH8ED';
+        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);
-    }
-    async multicallContractsMethods(contractAbi, contractsData) {
-        const calls = contractsData.map(({ contractAddress, methodsData }) => {
-            return methodsData.map(({ methodName, methodArguments }) => [
-                contractAddress,
-                tron_web3_pure_1.TronWeb3Pure.encodeFunctionCall(contractAbi, methodName, methodArguments)
-            ]);
+    initWeb3Client() {
+        const rpc = typeof this.rpcList[0] === 'string' ? this.rpcList[0] : this.rpcList[0].fullHost;
+        const headers = this.clientParams?.tronwebHeaders;
+        this.public = new tronweb_1.TronWeb({
+            fullHost: rpc,
+            ...(headers && { headers })
         });
-        try {
-            const outputs = await this.multicall(calls.flat());
-            let outputIndex = 0;
-            return contractsData.map((contractData) => contractData.methodsData.map((methodData) => {
-                const success = outputs.results[outputIndex];
-                const returnData = outputs.returnData[outputIndex];
-                outputIndex++;
-                const methodOutputAbi = contractAbi.find(
-                // @ts-ignore
-                (funcSignature) => funcSignature.name === methodData.methodName
-                // @ts-ignore
-                ).outputs;
-                return {
-                    output: success ? tron_web3_pure_1.TronWeb3Pure.decodeMethodOutput(methodOutputAbi, returnData) : null,
-                    success
-                };
-            }));
-        }
-        catch {
-            return this.multicallContractsMethodsByOne(contractAbi, contractsData);
-        }
-    }
-    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 = []) {
+    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);
     }
-    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));
-                    return {
-                        output,
-                        success: true
-                    };
-                }
-                catch {
-                    return {
-                        output: null,
-                        success: false
-                    };
-                }
-            }));
-        }));
+    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((address) => web3_pure_1.Web3Pure.isNativeAddress(core_1.CHAIN_TYPE.TRON, address));
+        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.multicallContractsMethods(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, tokensAddresses.map((tokenAddress) => ({
-            contractAddress: tokenAddress,
-            methodsData: [
-                {
-                    methodArguments: [userAddress],
-                    methodName: 'balanceOf'
-                }
-            ]
-        })));
+        promises[0] = this.batchMulticallTokenBalance(userAddress, tokensAddresses, 20);
         const results = await Promise.all(promises);
         const tokensBalances = results[0].map((tokenResults) => {
             const { success, output } = tokenResults[0];
@@ -109,6 +73,66 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
         }
         return tokensBalances;
     }
+    async batchMulticallTokenBalance(userAddress, tokensAddresses, batchSize) {
+        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;
+    }
+    async multicallContractsMethods(contractAbi, contractsData) {
+        const calls = contractsData.map(({ contractAddress, methodsData }) => {
+            return methodsData.map(({ methodName, methodArguments }) => [
+                contractAddress,
+                true,
+                tron_web3_pure_1.TronWeb3Pure.encodeFunctionCall(contractAbi, methodName, methodArguments)
+            ]);
+        });
+        try {
+            const outputs = await this.multicall(calls.flat());
+            let outputIndex = 0;
+            return contractsData.map((contractData) => contractData.methodsData.map((methodData) => {
+                const output = outputs.returnData[outputIndex];
+                if (!output)
+                    return { output: null, success: false };
+                const methodOutputAbi = contractAbi.find((funcSignature) => funcSignature.name === methodData.methodName).outputs;
+                outputIndex++;
+                return {
+                    output: output.success ? tron_web3_pure_1.TronWeb3Pure.decodeMethodOutput(methodOutputAbi, output.returnData) : null,
+                    success: output.success
+                };
+            }));
+        }
+        catch (err) {
+            this.logger
+                ? this.logger.customError('[TronAdapter_multicallContractsMethods] Error: ', err)
+                : console.debug('[TronAdapter_multicallContractsMethods] Error:', err);
+            return contractsData.map((contractData) => contractData.methodsData.map(() => ({ output: null, success: false })));
+        }
+    }
+    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.weiAmount);
+    }
+    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['aggregate3'](calls).call();
+    }
     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 +208,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 +225,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>;
+}

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractAdapter = void 0;
+const viem_1 = require("viem");
+const core_1 = require("@cryptorubic/core");
+const insufficient_funds_error_1 = require("../../../errors/swap/insufficient-funds.error");
+const tx_status_1 = require("../models/web3-public-models/tx-status");
+const waitFor_1 = require("../utils/waitFor");
+class AbstractAdapter {
+    set public(value) {
+        this._publicRef.public = value;
+    }
+    get public() {
+        if (!this._publicRef.public) {
+            const msg = `Trying to access undefined public client in ${this.blockchain} adapter.`;
+            this.logger?.customLog(msg);
+            throw new Error(msg);
+        }
+        return this._publicRef.public;
+    }
+    get publicRef() {
+        return this._publicRef;
+    }
+    get connected() {
+        return !!this._publicRef.public;
+    }
+    constructor(blockchain, logger) {
+        /**
+         * used to pass public pointer in signer constructor
+         */
+        this._publicRef = { public: null };
+        this.blockchain = blockchain;
+        if (logger) {
+            this.logger = logger;
+        }
+    }
+    /**
+     * Gets token info by address.
+     * @param tokenAddress Address of token.
+     * @param tokenFields Token's fields to get.
+     */
+    async callForTokenInfo(tokenAddress) {
+        return (await this.callForTokensInfo([tokenAddress]))[0];
+    }
+    /**
+     * 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.
+     */
+    async checkBalance(token, requiredAmount, userAddress) {
+        const enoughBalance = await this.checkEnoughBalance(new core_1.TokenAmount({ ...token, tokenAmount: requiredAmount }), userAddress);
+        if (!enoughBalance) {
+            throw new insufficient_funds_error_1.InsufficientFundsError(token.symbol);
+        }
+    }
+    needPreswapAction(token, contractAddress, walletAddress, amount) {
+        return Promise.resolve(false);
+    }
+    handlePreswap(contractAddress, walletAddress, tokenAmount) {
+        return Promise.resolve();
+    }
+    static getRandomBytes(bytes) {
+        const randomBytes = crypto.getRandomValues(new Uint8Array(bytes));
+        return (0, viem_1.bytesToHex)(randomBytes);
+    }
+    async getSrcTxStatus(blockchain, srcTxHash) {
+        try {
+            const status = await this.getTransactionStatus(srcTxHash);
+            if (status === tx_status_1.TX_STATUS.FAIL && blockchain === core_1.BLOCKCHAIN_NAME.ZK_SYNC) {
+                const zkSyncAwarenessTime = 4000;
+                await (0, waitFor_1.waitFor)(zkSyncAwarenessTime);
+                return this.getTransactionStatus(srcTxHash);
+            }
+            return status;
+        }
+        catch {
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+    }
+}
+exports.AbstractAdapter = AbstractAdapter;

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

@@ -0,0 +1,22 @@
+import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
+export declare abstract class AbstractAdapterSigner<ClientWallet, SendTxParams, SendTxResponse> {
+    protected readonly httpClient: HttpClient;
+    protected readonly logger?: ICustomLogger | undefined;
+    protected readonly clientParams?: ClientAdaptersFactoryParams | undefined;
+    protected get apiUrl(): string;
+    private _walletAddress;
+    get walletAddress(): string;
+    private _wallet;
+    get wallet(): ClientWallet;
+    constructor(httpClient: HttpClient, logger?: ICustomLogger | undefined, clientParams?: ClientAdaptersFactoryParams | undefined);
+    abstract getBlockchainName(): Promise<BlockchainName | undefined>;
+    abstract sendTransaction(params: SendTxParams): Promise<SendTxResponse>;
+    abstract write(...args: unknown[]): Promise<string>;
+    /**
+     * Checks, that selected blockchain in wallet is equal to passed blockchain.
+     */
+    checkBlockchainCorrect(blockchainName: BlockchainName): Promise<void | never>;
+    setWalletAddress(newWalletAddress: string): void;
+    setWallet(wallet: ClientWallet): void;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractAdapterSigner = void 0;
+const rubic_api_link_mapping_1 = require("../../../constants/rubic-api-link-mapping");
+const wrong_network_error_1 = require("../../../../errors/swap/wrong-network.error");
+class AbstractAdapterSigner {
+    get apiUrl() {
+        if (!this.clientParams?.envType) {
+            this.logger?.customError('clientParams.envType is not set for apiUrl call.');
+            throw new Error('clientParams.envType is not set for apiUrl call.');
+        }
+        const rubicApiLink = rubic_api_link_mapping_1.rubicApiLinkMapping[this.clientParams.envType];
+        return rubicApiLink ? rubicApiLink : 'https://dev1-api-v2.rubic.exchange';
+    }
+    get walletAddress() {
+        return this._walletAddress;
+    }
+    get wallet() {
+        return this._wallet;
+    }
+    constructor(httpClient, logger, clientParams) {
+        this.httpClient = httpClient;
+        this.logger = logger;
+        this.clientParams = clientParams;
+    }
+    /**
+     * Checks, that selected blockchain in wallet is equal to passed blockchain.
+     */
+    async checkBlockchainCorrect(blockchainName) {
+        const userBlockchainName = await this.getBlockchainName();
+        if (userBlockchainName !== blockchainName) {
+            throw new wrong_network_error_1.WrongNetworkError(blockchainName);
+        }
+    }
+    setWalletAddress(newWalletAddress) {
+        this._walletAddress = newWalletAddress;
+    }
+    setWallet(wallet) {
+        this._wallet = wallet;
+    }
+}
+exports.AbstractAdapterSigner = AbstractAdapterSigner;

package/src/lib/adapter/adapters/constants/trc-20-contract-abi.d.ts

@@ -10,3 +10,4 @@ export declare const TRC20_CONTRACT_ABI: {
     stateMutability: string;
     type: string;
 }[];
+export type TronAbiItem = (typeof TRC20_CONTRACT_ABI)[number];

package/src/lib/adapter/adapters/constants/tron-multicall-abi.js

@@ -7,18 +7,25 @@ exports.TRON_MULTICALL_ABI = [
             {
                 components: [
                     { internalType: 'address', name: 'target', type: 'address' },
+                    { internalType: 'bool', name: 'allowFailure', type: 'bool' },
                     { internalType: 'bytes', name: 'callData', type: 'bytes' }
                 ],
-                internalType: 'struct Multicall.Call[]',
+                internalType: 'struct Multicall3.Call3[]',
                 name: 'calls',
                 type: 'tuple[]'
             }
         ],
-        name: 'aggregateViewCalls',
+        name: 'aggregate3',
         outputs: [
-            { internalType: 'uint256', name: 'blockNumber', type: 'uint256' },
-            { internalType: 'bytes[]', name: 'returnData', type: 'bytes[]' },
-            { internalType: 'bool[]', name: 'results', type: 'bool[]' }
+            {
+                components: [
+                    { internalType: 'bool', name: 'success', type: 'bool' },
+                    { internalType: 'bytes', name: 'returnData', type: 'bytes' }
+                ],
+                internalType: 'struct Multicall3.Result[]',
+                name: 'returnData',
+                type: 'tuple[]'
+            }
         ],
         stateMutability: 'view',
         type: 'function'

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

@@ -1,9 +1,11 @@
 import { BlockchainName, TokenAmount } from '@cryptorubic/core';
 import { AllowanceInfo } from './common-types';
-import { AbstractAdapter } from '../abstract-adapter';
 import { EvmTransactionConfig } from '../../../utils/models/evm-transaction-config';
 import { TronTransactionConfig } from '../../../utils/models/tron-transaction-config';
-export interface ApproveAdapter<T> extends AbstractAdapter<any, any, BlockchainName> {
+import { AbstractAdapter } from '../common/abstract-adapter';
+import BigNumber from 'bignumber.js';
+import { BasicSendTransactionOptions } from './basic-transaction-options';
+export interface ApprovableAdapter<T> extends AbstractAdapter<any, any, BlockchainName, {}> {
     /**
      * @param fromTokenAddress erc20 address of checked token
      * @param walletAddress owner wallet address
@@ -27,11 +29,13 @@ export interface ApproveAdapter<T> extends AbstractAdapter<any, any, BlockchainN
      */
     needApprove(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
     /**
-     * Get data for tokens approve
-     * @param tokenAddress erc20 token address
-     * @param spenderAddress spender address
-     * @param amount amount in non wei
+     * Executes approve method in ERC-20 token contract.
+     * @param tokenAddress Address of the smart-contract corresponding to the token.
+     * @param spenderAddress Wallet or contract address to approve.
+     * @param amount Token amount to approve in wei.
+     * @param [options] Additional options.
+     * @returns Approval transaction receipt.
      */
-    approve(walletAddress: string, tokenAddress: string, spenderAddress: string, amount?: string): Promise<string>;
+    approveTokens(tokenAddress: string, spenderAddress: string, amount: BigNumber | 'infinity', options: BasicSendTransactionOptions): Promise<string>;
 }
-export declare function isApprovableAdapter(adapter: AbstractAdapter<any, any, BlockchainName>): adapter is ApproveAdapter<EvmTransactionConfig | TronTransactionConfig>;
+export declare function isApprovableAdapter(adapter: AbstractAdapter<any, any, BlockchainName, {}>): adapter is ApprovableAdapter<EvmTransactionConfig | TronTransactionConfig>;

package/src/lib/adapter/adapters/models/approve-adapter.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isApprovableAdapter = isApprovableAdapter;
 function isApprovableAdapter(adapter) {
-    return 'needApprove' in adapter && 'approve' in adapter && 'getAllowance' in adapter && 'encodeApprove' in adapter;
+    return 'needApprove' in adapter && 'approveTokens' in adapter && 'getAllowance' in adapter && 'encodeApprove' in adapter;
 }

package/src/lib/adapter/adapters/models/basic-transaction-options.d.ts

@@ -1,4 +1,4 @@
-export interface BasicTransactionOptions {
+export interface BasicSendTransactionOptions {
     /**
      * Callback to be called, when user confirm swap transaction.
      * @param hash Transaction hash.

package/src/lib/adapter/adapters/models/evm-web3-public-models/batch-call.d.ts

@@ -0,0 +1,5 @@
+export interface BatchCall {
+    to: string;
+    data: string;
+    value?: string;
+}

package/src/lib/adapter/adapters/models/evm-web3-public-models/batch-call.js

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

package/src/lib/adapter/adapters/models/evm-web3-public-models/evm-call.d.ts

@@ -0,0 +1,4 @@
+export interface EvmCall {
+    target: string;
+    callData: string;
+}