@cryptorubic/web3 0.0.34 → 0.0.37-alpha-1212.0

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

@@ -0,0 +1,120 @@
+import { Abi, MulticallResponse, MulticallParameters, PublicActions, PublicClient, WalletClient, WalletActions, BlockNumber, BlockTag, GetBlockReturnType, TransactionReceipt } from 'viem';
+import { AbstractAdapter } from '../common/abstract-adapter';
+import { EvmBlockchainName, ICustomLogger, Token, TokenAmount, PriceTokenAmount, HttpClient } from '@cryptorubic/core';
+import BigNumber from 'bignumber.js';
+import { EvmAdapterOptions } from '../models/evm-adapter-options';
+import { EvmTransactionConfig } from '../../../utils/models/evm-transaction-config';
+import { EvmAdapterSigner } from './signer/evm-adapter-signer';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
+import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
+import { ContractMulticallResponse } from '../models/web3-public-models/contract-multicall-response';
+import { MethodData } from '../models/web3-public-models/method-data';
+import { GasPrice } from '../models/evm-web3-public-models/gas-price';
+import { EvmTransactionOptions } from './models/evm-send-tx-params';
+import { ApprovableAdapter } from '../models/approve-adapter';
+import { AllowanceInfo } from '../models/common-types';
+import { TxStatus } from '../models/web3-public-models/tx-status';
+export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicClient, WalletClient & WalletActions, EvmBlockchainName> implements ApprovableAdapter<EvmTransactionConfig> {
+    private readonly adapterOptions;
+    private readonly clientParams?;
+    readonly signer: EvmAdapterSigner;
+    needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
+    handlePreswap(contractAddress: string, walletAddress: string, tokenAmount: TokenAmount): Promise<void>;
+    constructor(httpClient: HttpClient, adapterOptions: EvmAdapterOptions, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams | undefined);
+    initWeb3Client(): void;
+    callContractMethod<T extends Web3PrimitiveType = string>(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments?: unknown[], options?: {
+        from?: string;
+        value?: string;
+        gasPrice?: string;
+        gas?: string;
+    }): Promise<T>;
+    getTransactionStatus(hash: string): Promise<TxStatus>;
+    /**
+     * Gets mined transaction receipt.
+     * @param hash Transaction hash
+     */
+    private getTransactionReceipt;
+    getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    multicallContractsMethods<Output extends Web3PrimitiveType>(contractAbi: Abi, contractsData: {
+        contractAddress: string;
+        methodsData: MethodData[];
+    }[]): Promise<ContractMulticallResponse<Output>[][]>;
+    getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        workchain: number;
+    }>;
+    private createPublicClient;
+    multicallByContract<T>(contracts: MulticallParameters, allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
+    multicallByAddress<T>(address: string, abi: Abi, method: string, methodArgs?: unknown[][], allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
+    static encodeMethodCall(contractAddress: string, contractAbi: Abi, method: string, parameters?: unknown[], value?: string): EvmTransactionConfig;
+    read<T>(address: string, abi: Abi, method: string, methodArgs?: unknown[]): Promise<T>;
+    /**
+     * Generate random HEX strings from a given byte size.
+     * @param size byte size.
+     */
+    static randomHex(size: number): string;
+    /**
+     * Converts address to checksum format.
+     * @param address Address to convert.
+     */
+    static toChecksumAddress(address: string): string;
+    simulateTransaction(config: EvmTransactionConfig, from: string, timeout?: number): Promise<string>;
+    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<EvmBlockchainName>[]>;
+    getGasPrice(): Promise<string>;
+    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string, amount?: BigNumber): Promise<boolean>;
+    /**
+     * @param walletAddress
+     * @param tokenAddress
+     * @returns wei amount
+     */
+    getBalance(walletAddress: string, tokenAddress?: string): Promise<BigNumber>;
+    getTransactionCount(walletAddress: string): Promise<number>;
+    getAllowance(fromTokenAddress: string, walletAddress: string, spenderAddress: string): Promise<AllowanceInfo>;
+    needApprove(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
+    /**
+     * 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 hash.
+     */
+    approveTokens(tokenAddress: string, spenderAddress: string, amount?: BigNumber | 'infinity', options?: EvmTransactionOptions): Promise<string>;
+    /**
+     * Build encoded approve transaction config.
+     * @param tokenAddress Address of the smart-contract corresponding to the token.
+     * @param spenderAddress Wallet or contract address to approve.
+     * @param amount wei amount of tokens in approval window in spending cap field
+     * @returns Encoded approve transaction config.
+     */
+    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): EvmTransactionConfig;
+    needPermit2Approve(token: TokenAmount, permit2Address: string, walletAddress: string, spenderAddress: string): Promise<boolean>;
+    /**
+     * @param tokenAddress Token address you want to approve for spending
+     * @param permit2Address Addres of permit2 contract
+     * @param spenderAddress Contract address spending your tokens
+     * @param amount Approved amount
+     * @param deadline Ms number added to current time (Date.now()) until approve expiration
+     */
+    approveOnPermit2(tokenAddress: string, spenderAddress: string, amount?: BigNumber | 'infinity', options?: EvmTransactionOptions): Promise<TransactionReceipt>;
+    /**
+     * Calculates EIP-1559 specific gas details.
+     * @see {@link https://github.com/ethers-io/ethers.js/blob/master/packages/abstract-provider/src.ts/index.ts#L235}
+     * @returns block baseFee, average maxPriorityFeePerGas, and maxFeePerGas.
+     */
+    getPriorityFeeGas(): Promise<GasPrice>;
+    /**
+     * Gets block by block id.
+     * @param [blockId] Block id: hash, number ... Default is 'latest'.
+     * @returns Block by blockId parameter.
+     */
+    getBlock(blockType?: BlockNumber | BlockTag): Promise<GetBlockReturnType>;
+    /**
+     * Estimates average maxPriorityFeePerGas for EIP-1559 transactions based on last 20 blocks.
+     * @see {@link https://docs.alchemy.com/docs/how-to-build-a-gas-fee-estimator-using-eip-1559}
+     * @returns Average maxPriorityFeePerGas in wei
+     */
+    getMaxPriorityFeePerGas(): Promise<number>;
+    getBaseFeePerGas(blockNumber: bigint): Promise<number>;
+    private handlePossibleError;
+}

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

@@ -0,0 +1,498 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmAdapter = void 0;
+const viem_1 = require("viem");
+const viem_blockchain_mapping_1 = require("../../constants/viem-blockchain-mapping");
+const erc20_token_abi_1 = require("../constants/erc20-token-abi");
+const abstract_adapter_1 = require("../common/abstract-adapter");
+const core_1 = require("@cryptorubic/core");
+const bignumber_js_1 = require("bignumber.js");
+const web3_pure_1 = require("../../../utils/web3-pure");
+const possible_errors_1 = require("../constants/possible-errors");
+const evm_adapter_signer_1 = require("./signer/evm-adapter-signer");
+const rubic_sdk_error_1 = require("../../../errors/rubic-sdk.error");
+const uni_v3_permit_abi_1 = require("../constants/uni-v3-permit-abi");
+const insufficient_funds_gas_price_value_error_1 = require("../../../errors/cross-chain/insufficient-funds-gas-price-value.error");
+const options_1 = require("../utils/options");
+const tx_status_1 = require("../models/web3-public-models/tx-status");
+class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
+    async needPreswapAction(token, contractAddress, walletAddress, amount) {
+        return this.needApprove(token, contractAddress, walletAddress, amount);
+    }
+    async handlePreswap(contractAddress, walletAddress, tokenAmount) {
+        const approveAmount = this.blockchain === core_1.BLOCKCHAIN_NAME.GNOSIS || this.blockchain === core_1.BLOCKCHAIN_NAME.CRONOS
+            ? tokenAmount.stringWeiAmount
+            : tokenAmount.stringTokenAmount;
+        const isNative = web3_pure_1.Web3Pure.isNativeAddress(this.blockchain, tokenAmount.address);
+        const fromTokenAddress = isNative && tokenAmount.blockchain === core_1.BLOCKCHAIN_NAME.METIS
+            ? '0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000'
+            : tokenAmount.blockchain;
+        await this.signer.writeContract(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'approve', '0', [approveAmount]);
+    }
+    constructor(httpClient, adapterOptions, logger, clientParams) {
+        super(adapterOptions.blockchain, logger);
+        this.adapterOptions = adapterOptions;
+        this.clientParams = clientParams;
+        this.signer = new evm_adapter_signer_1.EvmAdapterSigner(this.publicRef, httpClient, logger, clientParams);
+    }
+    initWeb3Client() {
+        this.public = this.createPublicClient(this.adapterOptions.rpcList);
+    }
+    async callContractMethod(contractAddress, contractAbi, methodName, methodArguments = [], options = {}) {
+        return this.public.readContract({
+            abi: contractAbi,
+            address: contractAddress,
+            functionName: methodName,
+            args: methodArguments,
+            ...(options.from && { account: options.from })
+        });
+    }
+    async getTransactionStatus(hash) {
+        const txReceipt = await this.getTransactionReceipt(hash);
+        if (txReceipt === null) {
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+        if (txReceipt.status) {
+            return tx_status_1.TX_STATUS.SUCCESS;
+        }
+        return tx_status_1.TX_STATUS.FAIL;
+    }
+    /**
+     * Gets mined transaction receipt.
+     * @param hash Transaction hash
+     */
+    async getTransactionReceipt(hash) {
+        return this.public.getTransactionReceipt({ hash: hash });
+    }
+    async getTokensBalances(userAddress, tokensAddresses) {
+        const indexOfNativeCoin = tokensAddresses.findIndex((tokenAddress) => web3_pure_1.Web3Pure.isNativeAddress('ETH', tokenAddress));
+        const promises = [];
+        if (indexOfNativeCoin !== -1) {
+            tokensAddresses.splice(indexOfNativeCoin, 1);
+            promises[1] = this.getBalance(userAddress);
+        }
+        promises[0] = this.multicallContractsMethods(erc20_token_abi_1.erc20TokenAbi, tokensAddresses.map((tokenAddress) => ({
+            contractAddress: tokenAddress,
+            methodsData: [
+                {
+                    methodName: 'balanceOf',
+                    methodArguments: [userAddress]
+                }
+            ]
+        })));
+        const results = await Promise.all(promises);
+        const tokensBalances = results[0].map((tokenResults) => {
+            const { success, output } = tokenResults[0];
+            return success ? new bignumber_js_1.default(output) : new bignumber_js_1.default(0);
+        });
+        if (indexOfNativeCoin !== -1) {
+            tokensBalances.splice(indexOfNativeCoin, 0, results[1]);
+        }
+        return tokensBalances;
+    }
+    async multicallContractsMethods(contractAbi, contractsData) {
+        const contracts = contractsData
+            .map(({ contractAddress, methodsData }) => {
+            const wagmiContract = {
+                address: contractAddress,
+                abi: contractAbi
+            };
+            return methodsData.map(({ methodName, methodArguments }) => ({
+                ...wagmiContract,
+                functionName: methodName,
+                args: methodArguments
+            }));
+        })
+            .flat();
+        const outputs = await this.public.multicall({ contracts });
+        let outputIndex = 0;
+        return contractsData.map((contractData) => {
+            return contractData.methodsData.map(() => {
+                const output = outputs[outputIndex];
+                if (!output) {
+                    throw new rubic_sdk_error_1.RubicSdkError('Output has to be defined');
+                }
+                outputIndex++;
+                return {
+                    success: output.status === 'success',
+                    output: output?.error ? null : output.result
+                };
+            });
+        });
+    }
+    async getBlockNumber() {
+        const blockNumber = await this.public.getBlockNumber();
+        return Number(blockNumber);
+    }
+    createPublicClient(rpcList) {
+        if (!rpcList?.[0]) {
+            this.logger?.customError('RPC list is empty');
+            return null;
+        }
+        const customViemConfig = this.clientParams?.viemConfig?.[this.blockchain];
+        const defaultTransportConfig = {
+            batch: { batchSize: 2000, wait: 16 },
+            onFetchResponse: (response) => this.handlePossibleError(response),
+            retryCount: 2,
+            retryDelay: 100,
+            timeout: 5000
+        };
+        const defaultFallbackConfig = {
+            rank: {
+                interval: 1800000
+            }
+        };
+        const transports = rpcList.map((rpc) => {
+            return (0, viem_1.http)(rpc, customViemConfig?.transportConfig ? customViemConfig.transportConfig : defaultTransportConfig);
+        });
+        const fallbackConfig = customViemConfig?.fallbackConfig ? customViemConfig?.fallbackConfig : defaultFallbackConfig;
+        const chain = viem_blockchain_mapping_1.viemBlockchainMapping[this.blockchain];
+        return (0, viem_1.createPublicClient)({
+            // @ts-ignore
+            chain,
+            transport: (0, viem_1.fallback)(transports, fallbackConfig)
+        });
+    }
+    async multicallByContract(contracts, allowErrors = true) {
+        const results = await this.public.multicall(contracts);
+        const rpcRequestFail = results.every((result) => result?.status === 'failure');
+        if (rpcRequestFail) {
+            // @ts-ignore
+            if (rpcRequestFail?.[0]?.stats === 'failure') {
+                // @ts-ignore
+                throw new Error(rpcRequestFail?.[0]?.error);
+            }
+        }
+        const hasErrors = results.find((result) => {
+            if (result?.error || result.status !== 'success') {
+                this.logger?.customWarn('Multicall error', result?.error?.data || result?.error?.message || result?.error);
+                return true;
+            }
+            return false;
+        });
+        if (hasErrors && !allowErrors) {
+            throw new Error('Multicall error');
+        }
+        return results;
+    }
+    async multicallByAddress(address, abi, method, methodArgs = [], allowErrors = true) {
+        const contract = {
+            abi,
+            address: address,
+            functionName: method
+        };
+        const contracts = methodArgs.map((multicallArguments) => ({
+            ...contract,
+            args: multicallArguments
+        }));
+        return this.multicallByContract({ contracts }, allowErrors);
+    }
+    static encodeMethodCall(contractAddress, contractAbi, method, parameters = [], value) {
+        try {
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: contractAbi,
+                args: parameters,
+                functionName: method
+            });
+            return {
+                data: data,
+                to: contractAddress,
+                value: value || '0'
+            };
+        }
+        catch (err) {
+            throw err;
+        }
+    }
+    async read(address, abi, method, methodArgs = []) {
+        const result = await this.public.readContract({
+            abi,
+            address: address,
+            args: methodArgs,
+            functionName: method
+        });
+        return result;
+    }
+    /**
+     * Generate random HEX strings from a given byte size.
+     * @param size byte size.
+     */
+    static randomHex(size) {
+        const bytes = new Uint8Array(size);
+        crypto.getRandomValues(bytes);
+        return (0, viem_1.toHex)(bytes);
+    }
+    /**
+     * Converts address to checksum format.
+     * @param address Address to convert.
+     */
+    static toChecksumAddress(address) {
+        return (0, viem_1.getAddress)(address);
+    }
+    async simulateTransaction(config, from, timeout = 15000) {
+        try {
+            const callParams = {
+                account: from,
+                data: config.data,
+                to: config.to,
+                ...(config.value && { value: BigInt(config.value) })
+            };
+            const gasLimitWei = await Promise.race([
+                this.public.estimateGas(callParams),
+                new Promise((_, reject) => setTimeout(() => reject('Timeout'), timeout))
+            ]);
+            return gasLimitWei?.toString();
+        }
+        catch (err) {
+            this.logger?.customError('Error while simulating transaction', err);
+            throw err;
+        }
+    }
+    async callForTokensInfo(tokenAddresses) {
+        const nativeTokenIndex = tokenAddresses.findIndex((address) => (0, core_1.compareAddresses)(address, '0x0000000000000000000000000000000000000000'));
+        const filteredTokenAddresses = tokenAddresses.filter((_, index) => index !== nativeTokenIndex);
+        const contracts = filteredTokenAddresses.flatMap((contractAddress) => {
+            const contract = {
+                abi: erc20_token_abi_1.erc20TokenAbi,
+                address: contractAddress
+            };
+            return ['decimals', 'symbol', 'name'].map((method) => ({ ...contract, functionName: method }));
+        });
+        const results = contracts.length
+            ? (await this.multicallByContract({ contracts }, false))
+            : [];
+        const tokens = [];
+        for (let i = 0; i < results.length; i += 3) {
+            try {
+                const decimals = Number(results[i].result);
+                const symbol = results[i + 1].result;
+                const name = results[i + 2].result;
+                const token = new core_1.Token({
+                    address: filteredTokenAddresses[i / 3],
+                    blockchain: this.blockchain,
+                    decimals,
+                    name,
+                    symbol
+                });
+                tokens.push(token);
+            }
+            catch (err) {
+                this.logger?.customError('Error while loading token', err);
+                tokens.push(null);
+            }
+        }
+        if (nativeTokenIndex === -1) {
+            return tokens.filter(Boolean);
+        }
+        const blockchainNativeToken = core_1.nativeTokensList[this.blockchain];
+        tokens.splice(nativeTokenIndex, 0, blockchainNativeToken);
+        return tokens.filter(Boolean);
+    }
+    async getGasPrice() {
+        const bigIntGas = await this.public.getGasPrice();
+        return String(bigIntGas);
+    }
+    async checkEnoughBalance(token, walletAddress, amount = token.tokenAmount) {
+        const weiBalance = await this.getBalance(walletAddress, token.isNative ? undefined : token.address);
+        const balance = core_1.Token.fromWei(weiBalance, token.decimals);
+        return balance.gte(amount);
+    }
+    /**
+     * @param walletAddress
+     * @param tokenAddress
+     * @returns wei amount
+     */
+    async getBalance(walletAddress, tokenAddress) {
+        const isToken = tokenAddress && !web3_pure_1.Web3Pure.isNativeAddress(core_1.CHAIN_TYPE.EVM, tokenAddress);
+        if (isToken) {
+            const tokenBalance = await this.read(tokenAddress, erc20_token_abi_1.erc20TokenAbi, 'balanceOf', [walletAddress]);
+            return new bignumber_js_1.default(tokenBalance);
+        }
+        const nativeBalance = await this.public.getBalance({
+            address: walletAddress
+        });
+        return new bignumber_js_1.default(nativeBalance.toString());
+    }
+    async getTransactionCount(walletAddress) {
+        const transactionCount = await this.public?.getTransactionCount({
+            address: walletAddress
+        });
+        return transactionCount ?? 0;
+    }
+    async getAllowance(fromTokenAddress, walletAddress, spenderAddress) {
+        const [decimals, allowance] = await Promise.all([
+            this.read(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'decimals'),
+            this.read(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'allowance', [walletAddress, spenderAddress])
+        ]);
+        const allowanceWeiBN = new bignumber_js_1.default(allowance);
+        const allowanceNonWei = core_1.Token.fromWei(allowanceWeiBN, Number(decimals));
+        return { allowanceNonWei, allowanceWei: allowanceWeiBN };
+    }
+    async needApprove(token, contractAddress, walletAddress, amount) {
+        // Native coin in METIS can be Token required approve
+        if (token.isNative && token.blockchain !== core_1.BLOCKCHAIN_NAME.METIS) {
+            return false;
+        }
+        // Special native address for METIS native coin
+        const fromTokenAddress = token.isNative && token.blockchain === core_1.BLOCKCHAIN_NAME.METIS ? '0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000' : token.address;
+        const { allowanceWei } = await this.getAllowance(fromTokenAddress, walletAddress, contractAddress);
+        return allowanceWei.lt(token.weiAmount);
+    }
+    /**
+     * 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 hash.
+     */
+    async approveTokens(tokenAddress, spenderAddress, amount = 'infinity', options = {}) {
+        try {
+            const rawValue = amount === 'infinity' ? new bignumber_js_1.default(2).pow(256).minus(1) : amount;
+            const encodedApprove = this.encodeApprove(tokenAddress, spenderAddress, rawValue.toFixed(0));
+            const gaslessParams = {
+                account: this.signer.walletAddress,
+                to: tokenAddress,
+                value: BigInt('0'),
+                data: encodedApprove.data
+            };
+            const gas = await this.public.estimateGas({
+                ...gaslessParams,
+                ...(0, options_1.getViemGasOptions)(options)
+            });
+            const gasfulViemOptions = {
+                ...gaslessParams,
+                ...(0, options_1.getViemGasOptions)(options),
+                gas: gas.toString()
+            };
+            const receipt = await this.signer.executeContractMethod(tokenAddress, erc20_token_abi_1.erc20TokenAbi, 'approve', [spenderAddress, BigInt(rawValue.toFixed(0))], gasfulViemOptions);
+            return receipt.transactionHash;
+        }
+        catch (err) {
+            if (err?.message?.includes('gas required exceeds allowance') || err?.message?.includes('insufficient balance to pay for gas')) {
+                throw new insufficient_funds_gas_price_value_error_1.InsufficientFundsGasPriceValueError();
+            }
+            console.debug(err);
+            throw err;
+        }
+    }
+    /**
+     * Build encoded approve transaction config.
+     * @param tokenAddress Address of the smart-contract corresponding to the token.
+     * @param spenderAddress Wallet or contract address to approve.
+     * @param amount wei amount of tokens in approval window in spending cap field
+     * @returns Encoded approve transaction config.
+     */
+    encodeApprove(tokenAddress, spenderAddress, amount) {
+        const amountWei = amount ?? new bignumber_js_1.default(2).pow(256).minus(1).toFixed();
+        const tx = EvmAdapter.encodeMethodCall(tokenAddress, erc20_token_abi_1.erc20TokenAbi, 'approve', [spenderAddress, amountWei]);
+        return {
+            data: tx.data,
+            to: tx.to,
+            value: tx.value
+        };
+    }
+    async needPermit2Approve(token, permit2Address, walletAddress, spenderAddress) {
+        const res = await this.read(permit2Address, uni_v3_permit_abi_1.UNI_V3_PERMIT_2_ABI, 'allowance', [
+            walletAddress,
+            token.address,
+            spenderAddress
+        ]);
+        const [amount, expiration, _nonce] = res;
+        return token.weiAmount.gt(amount) || new bignumber_js_1.default(Date.now()).gt(Number(expiration) * 1000);
+    }
+    /**
+     * @param tokenAddress Token address you want to approve for spending
+     * @param permit2Address Addres of permit2 contract
+     * @param spenderAddress Contract address spending your tokens
+     * @param amount Approved amount
+     * @param deadline Ms number added to current time (Date.now()) until approve expiration
+     */
+    async approveOnPermit2(tokenAddress, spenderAddress, amount = 'infinity', options = {}) {
+        const rawValue = amount === 'infinity' ? new bignumber_js_1.default(2).pow(256).minus(1) : amount;
+        return this.signer.executeContractMethod(tokenAddress, uni_v3_permit_abi_1.UNI_V3_PERMIT_2_ABI, 'approve', [spenderAddress, BigInt(rawValue.toString())], options);
+    }
+    /**
+     * Calculates EIP-1559 specific gas details.
+     * @see {@link https://github.com/ethers-io/ethers.js/blob/master/packages/abstract-provider/src.ts/index.ts#L235}
+     * @returns block baseFee, average maxPriorityFeePerGas, and maxFeePerGas.
+     */
+    async getPriorityFeeGas() {
+        const block = await this.getBlock('latest');
+        let lastBaseFeePerGas = null;
+        let maxFeePerGas = null;
+        let maxPriorityFeePerGas = null;
+        if (block && block.baseFeePerGas) {
+            const baseFeePerGas = await this.getBaseFeePerGas(block.number);
+            try {
+                lastBaseFeePerGas = baseFeePerGas;
+                maxPriorityFeePerGas = await this.getMaxPriorityFeePerGas();
+                maxFeePerGas = baseFeePerGas * 2 + maxPriorityFeePerGas;
+            }
+            catch (err) {
+                console.debug(err);
+            }
+        }
+        return {
+            baseFee: lastBaseFeePerGas?.toFixed(),
+            maxFeePerGas: maxFeePerGas?.toFixed(),
+            maxPriorityFeePerGas: maxPriorityFeePerGas?.toFixed()
+        };
+    }
+    /**
+     * Gets block by block id.
+     * @param [blockId] Block id: hash, number ... Default is 'latest'.
+     * @returns Block by blockId parameter.
+     */
+    getBlock(blockType = 'latest') {
+        if (typeof blockType === 'string') {
+            // @TODO FIX TYPE
+            return this.public.getBlock({ blockTag: blockType });
+        }
+        return this.public.getBlock({ blockNumber: blockType });
+    }
+    /**
+     * Estimates average maxPriorityFeePerGas for EIP-1559 transactions based on last 20 blocks.
+     * @see {@link https://docs.alchemy.com/docs/how-to-build-a-gas-fee-estimator-using-eip-1559}
+     * @returns Average maxPriorityFeePerGas in wei
+     */
+    async getMaxPriorityFeePerGas() {
+        const HISTORICAL_BLOCKS = 20;
+        const feeHistory = await this.public.getFeeHistory({
+            blockCount: HISTORICAL_BLOCKS,
+            rewardPercentiles: [50],
+            blockTag: 'pending'
+        });
+        if (!feeHistory?.reward) {
+            throw new Error('No fee history found');
+        }
+        const blocks = feeHistory.reward.map((x) => x.map((reward) => Number(reward)));
+        const rewardSum = blocks.map((x) => x[0]).reduce((acc, v) => acc + (v || 0), 0);
+        return Math.round(rewardSum / blocks.length);
+    }
+    async getBaseFeePerGas(blockNumber) {
+        const feeHistory = await this.public.getFeeHistory({
+            blockCount: 1,
+            rewardPercentiles: [50],
+            // blockTag: 'pending',
+            blockNumber: blockNumber
+        });
+        if (!feeHistory?.baseFeePerGas.length) {
+            throw new Error('No fee history found');
+        }
+        const feedSum = feeHistory.baseFeePerGas.reduce((acc, v) => acc.plus(v.toString() || 0), new bignumber_js_1.default(0));
+        return feedSum.dividedBy(feeHistory.baseFeePerGas.length).toNumber();
+    }
+    async handlePossibleError(response) {
+        const body = JSON.stringify(response.body);
+        const isError = !response.ok || 'error' in response || possible_errors_1.possibleErrors.some((error) => body.includes(error));
+        if (isError) {
+            this.logger?.customError('Rpc fetch error', {
+                blockchain: this.blockchain,
+                text: await response.text(),
+                url: response.url
+            });
+        }
+    }
+}
+exports.EvmAdapter = EvmAdapter;

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

@@ -0,0 +1,38 @@
+import BigNumber from 'bignumber.js';
+import { BasicSendTransactionOptions } from '../../models/basic-transaction-options';
+import { EIP1559Gas, SingleGasPrice } from '../../models/evm-web3-public-models/gas-price';
+export interface EvmSendTxParams {
+    txOptions: EvmTransactionOptions;
+}
+export interface EvmTransactionOptions extends EvmBasicTransactionOptions {
+    /**
+     * Encoded data, which will be executed in transaction.
+     */
+    data?: string;
+    /**
+     * Native token amount in wei.
+     */
+    value?: BigNumber | string | bigint;
+    /**
+     * Use in case of eip-155
+     */
+    chainId?: string;
+    /**
+     * gasLimit multiplier (to change ratio for specific chain)
+     */
+    gasLimitRatio?: number;
+    /**
+     * Address send transaction to
+     */
+    to?: string;
+}
+export interface EvmBasicTransactionOptions extends BasicSendTransactionOptions {
+    /**
+     * Transaction gas limit.
+     */
+    gas?: string;
+    /**
+     * Transaction gas price options.
+     */
+    gasPriceOptions?: EIP1559Gas | SingleGasPrice;
+}

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

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