@cryptorubic/web3 0.0.34 → 0.0.37-alpha-1212.0

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,22 +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);
+    }
+    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 }) => {
@@ -33,35 +110,42 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
                 const success = outputs.results[outputIndex];
                 const returnData = outputs.returnData[outputIndex];
                 outputIndex++;
+                const methodOutputAbi = contractAbi.find(
+                // @ts-ignore
+                (funcSignature) => funcSignature.name === methodData.methodName
                 // @ts-ignore
-                const methodOutputAbi = contractAbi.find((funcSignature) => funcSignature.name === methodData.methodName).outputs;
+                ).outputs;
                 return {
                     output: success ? tron_web3_pure_1.TronWeb3Pure.decodeMethodOutput(methodOutputAbi, returnData) : null,
                     success
                 };
             }));
         }
-        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.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.aggregateViewCalls(calls).call();
     }
-    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.callContractMethod(contractData.contractAddress, contractAbi, methodData.methodName, methodData.methodArguments));
+                    const output = (await this.read(contractData.contractAddress, contractAbi, methodData.methodName, methodData.methodArguments));
                     return {
                         output,
                         success: true
@@ -76,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));
@@ -154,21 +212,15 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
     async getTokenBalance(userAddress, tokenAddress) {
         this.public.setAddress(userAddress);
         const contract = await this.public.contract(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, tokenAddress);
-        // @ts-ignore
-        const balance = await contract.balanceOf(userAddress).call();
+        const balance = await contract
+            // @ts-ignore
+            .balanceOf(userAddress)
+            .call();
         return new bignumber_js_1.default(balance?.toString());
     }
     async convertTronAddressToHex(address) {
         return this.public.address.toHex(address);
     }
-    read() {
-        throw new Error('Method is not implemented');
-    }
-    ;
-    write() {
-        throw new Error('Method is not implemented');
-    }
-    ;
     static encodeMethodCall(contractAddress, contractAbi, methodName, methodArguments, callValue, feeLimit) {
         const methodAbi = contractAbi.find((abiItem) => abiItem.type === 'function' && abiItem.name === methodName);
         if (!methodAbi) {
@@ -183,40 +235,63 @@ 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')) {
+                const flattenedComponents = this.flattenTypesToString(
                 //@ts-ignore
-                const flattenedComponents = this.flattenTypesToString(abiInput.components);
+                abiInput.components);
                 return `(${flattenedComponents.join(',')})`;
             }
             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();
-        const callData = tron_web3_pure_1.TronWeb3Pure.encodeFunctionCall(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'approve', [spenderAddress, amountWei]);
-        return {
-            data: callData,
-            to: tokenAddress,
-            value: '0'
-        };
-    }
-    async getAllowance(fromTokenAddress, walletAddress, spender) {
-        const [contract, decimals] = await Promise.all([
-            this.public.contract(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, fromTokenAddress),
-            this.callContractMethod(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'decimals')
+        return TronAdapter.encodeMethodCall(tokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'approve', [
+            { type: 'address', value: spenderAddress },
+            { type: 'uint256', value: amountWei }
         ]);
-        const allowance = await this.getAllowance(fromTokenAddress, walletAddress, spender);
-        const allowanceWeiBN = new bignumber_js_1.default(allowance?.toString());
-        const allowanceNonWei = core_1.Token.fromWei(allowanceWeiBN, Number(decimals));
-        return { allowanceNonWei, allowanceWei: allowanceWeiBN };
     }
 }
 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/possible-errors.d.ts

@@ -0,0 +1 @@
+export declare const possibleErrors: string[];

package/src/lib/adapter/adapters/constants/possible-errors.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.possibleErrors = void 0;
+exports.possibleErrors = [
+    'not authorized',
+    'daily request count exceeded',
+    'invalid json rpc response',
+    "we can't execute this request",
+    'your account has been suspended',
+    'account suspended, please top up to reenable',
+    'your account has been suspended',
+    'too many requests, we recommend you to use free api key',
+    'origin not allowed'
+];

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

@@ -1,2 +1,2 @@
-import { AbiItem } from 'web3-utils';
+import { AbiItem } from '../../../utils/models/abi-types';
 export declare const TRON_MULTICALL_ABI: AbiItem[];

package/src/lib/adapter/adapters/constants/uni-v3-permit-abi.d.ts

@@ -0,0 +1,2 @@
+import { Abi } from 'viem';
+export declare const UNI_V3_PERMIT_2_ABI: Abi;