@cryptorubic/web3 0.14.0-alpha.solana-gas.12 → 1.0.0-alpha.no-sdk.1

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

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmAdapterClient = void 0;
+const core_1 = require("@cryptorubic/core");
+const abstract_adapter_client_1 = require("../../common/client/abstract-adapter-client");
+const waitForTransactionReceipt_1 = require("viem/_types/actions/public/waitForTransactionReceipt");
+const options_1 = require("../../utils/options");
+const viem_blockchain_mapping_1 = require("../../../constants/viem-blockchain-mapping");
+const bignumber_js_1 = require("bignumber.js");
+const uni_v3_permit_abi_1 = require("../../constants/uni-v3-permit-abi");
+const erc20_token_abi_1 = require("../../constants/erc20-token-abi");
+const parse_evm_error_1 = require("../utils/parse-evm-error");
+const rubic_sdk_error_1 = require("packages/web3/src/lib/errors/rubic-sdk.error");
+const evm_adapter_1 = require("../evm-adapter");
+const tx_status_1 = require("../../models/web3-public-models/tx-status");
+class EvmAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
+    constructor(evmAdapter, httpClient, logger, rubicAppParams) {
+        super(httpClient, logger, rubicAppParams);
+        this.evmAdapter = evmAdapter;
+    }
+    async getBlockchainName() {
+        const userChainId = await this.clientWallet.getChainId();
+        return core_1.BlockchainsInfo.getBlockchainNameById(userChainId);
+    }
+    async getAllowance(fromTokenAddress, walletAddress, spenderAddress) {
+        const [decimals, allowance] = await Promise.all([
+            this.evmAdapter.read(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'decimals'),
+            this.evmAdapter.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);
+    }
+    async approve(fromAddress, tokenAddress, spenderAddress, amount) {
+        const config = this.encodeApprove(tokenAddress, spenderAddress, amount);
+        return this.evmAdapter.write(fromAddress, config.to, config.value, config.data);
+    }
+    /**
+     * 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 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 = evm_adapter_1.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.evmAdapter.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.executeContractMethod(tokenAddress, uni_v3_permit_abi_1.UNI_V3_PERMIT_2_ABI, 'approve', [spenderAddress, BigInt(rawValue.toString())], options);
+    }
+    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.evmAdapter.public.getTransactionReceipt({ hash: hash });
+    }
+    /**
+     * 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.
+     */
+    async sendTransaction(params) {
+        try {
+            const to = params.txOptions.to;
+            const value = BigInt(params.txOptions.value?.toString() || '0');
+            const { account, chain } = await this.getChainAndAccount();
+            const viemParams = {
+                value,
+                account,
+                to,
+                ...(0, options_1.getViemGasOptions)(params.txOptions),
+                ...(params.txOptions.data && { data: params.txOptions.data }),
+                ...(params.txOptions.gas && { gas: BigInt(params.txOptions.gas) }),
+                chain
+            };
+            // @ts-ignore
+            const hash = await this.web3.sendTransaction(viemParams);
+            params.txOptions?.onTransactionHash?.(hash);
+            return (0, waitForTransactionReceipt_1.waitForTransactionReceipt)(this.clientWallet, { hash });
+        }
+        catch (err) {
+            console.error('Send transaction error', err);
+            throw err;
+        }
+    }
+    /**
+     * 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.
+     */
+    async trySendTransaction(toAddress, options) {
+        try {
+            const gaslessParams = {
+                account: this.walletAddress,
+                to: toAddress,
+                value: BigInt(options.value?.toString() || '0'),
+                ...(options.data && { data: options.data })
+            };
+            const gas = await this.evmAdapter.public.estimateGas(gaslessParams);
+            const gasfulParams = {
+                ...gaslessParams,
+                ...(0, options_1.getGasOptions)(options),
+                gas: gas.toString()
+            };
+            const gasfulViemParams = {
+                ...gaslessParams,
+                ...(0, options_1.getViemGasOptions)(options),
+                gas
+            };
+            try {
+                await this.evmAdapter.public.estimateGas(gasfulViemParams);
+            }
+            catch {
+                throw new rubic_sdk_error_1.RubicSdkError('Low native value');
+            }
+            const sendParams = {
+                ...gasfulParams,
+                ...(options.onTransactionHash && {
+                    onTransactionHash: options.onTransactionHash,
+                    gasPriceOptions: options?.gasPriceOptions
+                })
+            };
+            const receipt = await this.sendTransaction({ txOptions: sendParams });
+            return receipt;
+        }
+        catch (err) {
+            console.debug('Call tokens transfer error', err);
+            const shouldIgnore = await this.shouldIgnoreError(err);
+            if (shouldIgnore) {
+                return this.sendTransaction({ txOptions: options });
+            }
+            throw (0, parse_evm_error_1.parseEvmError)(err);
+        }
+    }
+    /**
+     * 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.
+     */
+    async executeContractMethod(contractAddress, contractAbi, methodName, methodArguments, options = {}) {
+        try {
+            const { account, chain } = await this.getChainAndAccount();
+            const sendParams = {
+                address: contractAddress,
+                abi: contractAbi,
+                functionName: methodName,
+                args: methodArguments,
+                ...(options.value && {
+                    value: BigInt(options.value?.toString())
+                }),
+                ...(options.gas && {
+                    gas: BigInt(options.gas)
+                }),
+                ...(0, options_1.getViemGasOptions)(options),
+                account: account,
+                chain: chain
+            };
+            const hash = await this.clientWallet.writeContract(sendParams);
+            options?.onTransactionHash?.(hash);
+            return (0, waitForTransactionReceipt_1.waitForTransactionReceipt)(this.clientWallet, { hash });
+        }
+        catch (err) {
+            console.error(`Method execution error. ${err}`);
+            throw (0, parse_evm_error_1.parseEvmError)(err);
+        }
+    }
+    /**
+     * 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.
+     */
+    async tryExecuteContractMethod(contractAddress, contractAbi, methodName, methodArguments, options = {}, allowError) {
+        try {
+            const gaslessParams = {
+                address: contractAddress,
+                abi: contractAbi,
+                functionName: methodName,
+                args: methodArguments,
+                ...(options.value && {
+                    value: BigInt(options.value?.toString())
+                }),
+                account: this.walletAddress
+            };
+            const gas = await this.evmAdapter.public.estimateContractGas(gaslessParams);
+            const gasfulParams = {
+                ...gaslessParams,
+                ...(0, options_1.getGasOptions)(options),
+                gas: gas.toString()
+            };
+            const gasfulViemParams = {
+                ...gaslessParams,
+                ...(0, options_1.getViemGasOptions)(options),
+                gas
+            };
+            try {
+                await this.evmAdapter.public.estimateContractGas(gasfulViemParams);
+            }
+            catch {
+                throw new rubic_sdk_error_1.RubicSdkError('Low native value');
+            }
+            const recepit = await this.executeContractMethod(contractAddress, contractAbi, methodName, methodArguments, {
+                ...gasfulParams,
+                ...(options.onTransactionHash && {
+                    onTransactionHash: options.onTransactionHash,
+                    gasPriceOptions: options?.gasPriceOptions
+                })
+            });
+            return recepit;
+        }
+        catch (err) {
+            if ((allowError && allowError(err)) || (await this.shouldIgnoreError(err))) {
+                return this.executeContractMethod(contractAddress, contractAbi, methodName, methodArguments, options);
+            }
+            console.error('Method execution error: ', err);
+            throw (0, parse_evm_error_1.parseEvmError)(err);
+        }
+    }
+    async shouldIgnoreError(error) {
+        if (error.message === 'Low native value' && (await this.getBlockchainName()) === core_1.BLOCKCHAIN_NAME.MANTLE) {
+            return true;
+        }
+        const ignoreCallErrors = [
+            'STF',
+            'execution reverted: ERC20: transfer amount exceeds allowance',
+            'Anyswaperc20: request exceed allowance',
+            'gas required exceeds allowance',
+            'execution reverted: SafeERC20: low-level call failed'
+        ];
+        const test = ignoreCallErrors.some((err) => error?.message?.toLowerCase().includes(err.toLowerCase()));
+        console.debug(test);
+        return test;
+    }
+    async signMessage(message) {
+        return this.clientWallet.signMessage({
+            account: this.walletAddress,
+            message: message
+        });
+    }
+    async getChainAndAccount() {
+        const account = this.walletAddress;
+        const chainId = await this.clientWallet.getChainId();
+        const chainName = core_1.BlockchainsInfo.getBlockchainNameById(chainId);
+        if (!chainName) {
+            throw Error(`Unsupported chain ID: ${chainId}. Please provide a valid EVM blockchain ID`);
+        }
+        const chain = viem_blockchain_mapping_1.viemBlockchainMapping[chainName];
+        if (!chain) {
+            throw Error(`Unsupported chain ID: ${chainId}. Please provide a valid EVM blockchain ID`);
+        }
+        return { account, chain };
+    }
+}
+exports.EvmAdapterClient = EvmAdapterClient;

package/src/lib/adapter/adapters/adapter-evm/constants/proxy-hash-errors.d.ts

@@ -0,0 +1,4 @@
+export declare const proxyHashErrors: {
+    text: string;
+    hash: string;
+}[];