@cryptorubic/web3 0.15.0-alpha-stellar.0 → 1.0.0-alpha-rub-1103.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/{evm-adapter.js → adapter-evm/evm-adapter.js}

@@ -2,14 +2,19 @@
 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("./abstract-adapter");
+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 uni_v3_permit_abi_1 = require("./constants/uni-v3-permit-abi");
+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);
@@ -22,68 +27,132 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
         const fromTokenAddress = isNative && tokenAmount.blockchain === core_1.BLOCKCHAIN_NAME.METIS
             ? '0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000'
             : tokenAmount.blockchain;
-        await this.writeContract(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'approve', '0', [approveAmount]);
+        await this.signer.writeContract(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'approve', '0', [approveAmount]);
     }
-    constructor(adapterOptions, logger) {
+    constructor(httpClient, adapterOptions, logger, clientParams) {
         super(adapterOptions.blockchain, logger);
-        this.public = this.createPublicClient(adapterOptions.rpcList);
+        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 transports = rpcList.map((rpc) => (0, viem_1.http)(rpc, {
+        const customViemConfig = this.clientParams?.viemConfig?.[this.blockchain];
+        const defaultTransportConfig = {
             batch: { batchSize: 2000, wait: 16 },
-            onFetchResponse: (response) => {
-                this.handlePossibleError(response);
-            },
+            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, {
-                rank: {
-                    interval: 1800000
-                }
-            })
+            transport: (0, viem_1.fallback)(transports, fallbackConfig)
         });
     }
-    async read(address, abi, method, methodArgs = []) {
-        const result = await this.public.readContract({
-            abi,
-            address: address,
-            args: methodArgs,
-            functionName: method
-        });
-        return result;
-    }
-    async writeContract(address, abi, method, value = '0', methodArgs = []) {
-        const result = await this.wallet.writeContract({
-            abi,
-            address: address,
-            account: address,
-            args: methodArgs,
-            functionName: method,
-            chain: this.public.chain,
-            value: (0, viem_1.parseEther)(value)
-        });
-        return result;
-    }
-    async write(address, to, value, data) {
-        const result = await this.wallet.sendTransaction({
-            account: address,
-            to: to,
-            value: (0, viem_1.parseEther)(value),
-            data: data,
-            chain: this.public.chain
-        });
-        return result;
-    }
     async multicallByContract(contracts, allowErrors = true) {
         const results = await this.public.multicall(contracts);
         const rpcRequestFail = results.every((result) => result?.status === 'failure');
@@ -135,6 +204,31 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             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 = {
@@ -209,14 +303,15 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
      * @returns wei amount
      */
     async getBalance(walletAddress, tokenAddress) {
-        if (!tokenAddress) {
-            const nativeBalance = await this.public.getBalance({
-                address: walletAddress
-            });
-            return new bignumber_js_1.default(nativeBalance.toString());
+        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 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({
@@ -233,15 +328,6 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
         const allowanceNonWei = core_1.Token.fromWei(allowanceWeiBN, Number(decimals));
         return { allowanceNonWei, allowanceWei: allowanceWeiBN };
     }
-    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 needApprove(token, contractAddress, walletAddress, amount) {
         // Native coin in METIS can be Token required approve
         if (token.isNative && token.blockchain !== core_1.BLOCKCHAIN_NAME.METIS) {
@@ -252,9 +338,59 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
         const { allowanceWei } = await this.getAllowance(fromTokenAddress, walletAddress, contractAddress);
         return allowanceWei.lt(token.weiAmount);
     }
-    async approve(fromAddress, tokenAddress, spenderAddress, amount) {
-        const config = this.encodeApprove(tokenAddress, spenderAddress, amount);
-        return this.write(fromAddress, config.to, config.value, config.data);
+    /**
+     * 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', [
@@ -265,24 +401,16 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
         const [amount, expiration, _nonce] = res;
         return token.weiAmount.gt(amount) || new bignumber_js_1.default(Date.now()).gt(Number(expiration) * 1000);
     }
-    encodePermit2Approve(tokenAddress, spenderAddress, permit2Address, expiration, amount) {
-        const tx = EvmAdapter.encodeMethodCall(permit2Address, uni_v3_permit_abi_1.UNI_V3_PERMIT_2_ABI, 'approve', [
-            tokenAddress,
-            spenderAddress,
-            amount,
-            expiration
-        ]);
-        return {
-            data: tx.data,
-            value: tx.value,
-            to: tx.to
-        };
-    }
-    async approveOnPermit2(fromAddress, tokenAddress, permit2Address, spenderAddress, deadline = new bignumber_js_1.default(1000000), amount) {
-        const approveAmount = amount ? amount : new bignumber_js_1.default(2).pow(256).minus(1);
-        const expiration = new bignumber_js_1.default(Date.now()).plus(deadline).toFixed();
-        const tx = this.encodePermit2Approve(tokenAddress, spenderAddress, permit2Address, expiration, approveAmount.toFixed());
-        return this.write(fromAddress, tx.to, tx.value, tx.data);
+    /**
+     * @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.

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 });

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

@@ -0,0 +1,53 @@
+import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
+import { AbstractAdapterSigner } from '../../common/signer/abstract-adapter-signer';
+import { Abi, PublicActions, PublicClient, TransactionReceipt, WalletActions, WalletClient } from 'viem';
+import { EvmSendTxParams, EvmTransactionOptions } from '../models/evm-send-tx-params';
+import { Web3Error } from '../utils/parse-evm-error';
+export declare class EvmAdapterSigner extends AbstractAdapterSigner<WalletClient & WalletActions, EvmSendTxParams, TransactionReceipt> {
+    private readonly publicRef;
+    get publicClient(): PublicActions & PublicClient;
+    constructor(publicRef: {
+        public: (PublicActions & PublicClient) | null;
+    }, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    getBlockchainName(): Promise<BlockchainName | undefined>;
+    /**
+     * Sends Eth in transaction and resolve the promise when the transaction is included in the block.
+     * @param toAddress Eth receiver address.
+     * @param [options] Additional options.
+     * @returns Transaction receipt.
+     */
+    sendTransaction(params: EvmSendTxParams): Promise<TransactionReceipt>;
+    /**
+     * Tries to send Eth in transaction and resolve the promise when the transaction is included in the block or rejects the error.
+     * @param toAddress Eth receiver address.
+     * @param [options] Additional options.
+     * @returns Transaction receipt.
+     */
+    trySendTransaction(params: EvmSendTxParams): Promise<TransactionReceipt>;
+    /**
+     * Executes method of smart-contract and resolve the promise when the transaction is included in the block.
+     * @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 Method name to execute.
+     * @param methodArguments Method arguments.
+     * @param [options] Additional options.
+     * @returns Smart-contract method returned value.
+     */
+    executeContractMethod(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments: unknown[], options?: EvmTransactionOptions): Promise<TransactionReceipt>;
+    /**
+     * Tries to execute method of smart-contract and resolve the promise when the transaction is included in the block or rejects the error.
+     * @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 Method name to execute.
+     * @param methodArguments Method arguments.
+     * @param [options] Additional options.
+     * @param allowError Check error and decides to execute contact if error is allowed.
+     */
+    tryExecuteContractMethod(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments: unknown[], options?: EvmTransactionOptions, allowError?: (err: Web3Error) => boolean): Promise<TransactionReceipt>;
+    private shouldIgnoreError;
+    signMessage(message: string): Promise<string>;
+    private getChainAndAccount;
+    writeContract(address: string, abi: Abi, method: string, value?: string, methodArgs?: unknown[]): Promise<string>;
+    write(address: string, to: string, value: string, data: string, options?: EvmTransactionOptions): Promise<string>;
+}