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

package/src/lib/adapter/adapters/{evm-adapter.d.ts → adapter-evm/evm-adapter.d.ts}

@@ -1,16 +1,31 @@
-import { Abi, MulticallResponse, MulticallParameters, PublicActions, PublicClient, WalletClient, WalletActions, BlockNumber, BlockTag, GetBlockReturnType } from 'viem';
-import { AbstractAdapter } from './abstract-adapter';
-import { EvmBlockchainName, ICustomLogger, Token, TokenAmount, PriceTokenAmount } from '@cryptorubic/core';
+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 { ApproveAdapter } from './models/approve-adapter';
-import { AllowanceInfo } from './models/common-types';
-import { GasPrice } from './models/gas-price';
-export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicClient, WalletClient & WalletActions, EvmBlockchainName> implements ApproveAdapter<EvmTransactionConfig> {
+import { EvmAdapterOptions } from '../models/evm-adapter-options';
+import { EvmTransactionConfig } from '../../../utils/models/evm-transaction-config';
+import { EvmSendTxParams } from './models/evm-send-tx-params';
+import { AbstractAdapterClient } from '../common/client/abstract-adapter-client';
+import { RubicAppAdaptersFactoryParams } from '../../constants/models/create-factory-params';
+import { ApproveAdapterClient } from '../models/approve-adapter';
+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';
+export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicClient, WalletClient & WalletActions, EvmBlockchainName> {
+    readonly client: AbstractAdapterClient<WalletClient & WalletActions, EvmSendTxParams, TransactionReceipt> & ApproveAdapterClient<EvmTransactionConfig>;
     needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
     handlePreswap(contractAddress: string, walletAddress: string, tokenAmount: TokenAmount): Promise<void>;
-    constructor(adapterOptions: EvmAdapterOptions, logger?: ICustomLogger);
+    constructor(httpClient: HttpClient, adapterOptions: EvmAdapterOptions, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    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;
+    }>;
     protected createPublicClient(rpcList: string[]): (PublicActions & PublicClient) | null;
     read<T>(address: string, abi: Abi, method: string, methodArgs?: unknown[]): Promise<T>;
     writeContract(address: string, abi: Abi, method: string, value?: string, methodArgs?: unknown[]): Promise<string>;
@@ -29,13 +44,6 @@ export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicCl
      */
     getBalance(walletAddress: string, tokenAddress?: string): Promise<BigNumber>;
     getTransactionCount(walletAddress: string): Promise<number>;
-    getAllowance(fromTokenAddress: string, walletAddress: string, spenderAddress: string): Promise<AllowanceInfo>;
-    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): EvmTransactionConfig;
-    needApprove(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
-    approve(fromAddress: string, tokenAddress: string, spenderAddress: string, amount?: string): Promise<string>;
-    needPermit2Approve(token: TokenAmount, permit2Address: string, walletAddress: string, spenderAddress: string): Promise<boolean>;
-    encodePermit2Approve(tokenAddress: string, spenderAddress: string, permit2Address: string, expiration: string, amount: string): EvmTransactionConfig;
-    approveOnPermit2(fromAddress: string, tokenAddress: string, permit2Address: string, spenderAddress: string, deadline?: BigNumber, amount?: BigNumber): Promise<string>;
     /**
      * 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}

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

@@ -2,17 +2,18 @@
 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_client_1 = require("./client/evm-adapter-client");
+const rubic_sdk_error_1 = require("../../../errors/rubic-sdk.error");
 class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
     async needPreswapAction(token, contractAddress, walletAddress, amount) {
-        return this.needApprove(token, contractAddress, walletAddress, amount);
+        return this.client.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
@@ -24,9 +25,70 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             : tokenAmount.blockchain;
         await this.writeContract(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'approve', '0', [approveAmount]);
     }
-    constructor(adapterOptions, logger) {
+    constructor(httpClient, adapterOptions, logger, rubicAppParams) {
         super(adapterOptions.blockchain, logger);
         this.public = this.createPublicClient(adapterOptions.rpcList);
+        this.client = new evm_adapter_client_1.EvmAdapterClient(this, httpClient, logger, rubicAppParams);
+    }
+    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]) {
@@ -34,22 +96,21 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             return null;
         }
         const transports = rpcList.map((rpc) => (0, viem_1.http)(rpc, {
-            batch: { batchSize: 2_000, wait: 16 },
+            batch: { batchSize: 2000, wait: 16 },
             onFetchResponse: (response) => {
                 this.handlePossibleError(response);
             },
             retryCount: 2,
             retryDelay: 100,
-            timeout: 5_000
+            timeout: 5000
         }));
         const chain = viem_blockchain_mapping_1.viemBlockchainMapping[this.blockchain];
-        // @ts-ignore
         return (0, viem_1.createPublicClient)({
             // @ts-ignore
             chain,
             transport: (0, viem_1.fallback)(transports, {
                 rank: {
-                    interval: 1_800_000
+                    interval: 1800000
                 }
             })
         });
@@ -64,7 +125,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
         return result;
     }
     async writeContract(address, abi, method, value = '0', methodArgs = []) {
-        const result = await this.wallet.writeContract({
+        const result = await this.client.clientWallet.writeContract({
             abi,
             address: address,
             account: address,
@@ -76,7 +137,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
         return result;
     }
     async write(address, to, value, data) {
-        const result = await this.wallet.sendTransaction({
+        const result = await this.client.clientWallet.sendTransaction({
             account: address,
             to: to,
             value: (0, viem_1.parseEther)(value),
@@ -136,7 +197,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             throw err;
         }
     }
-    async simulateTransaction(config, from, timeout = 15_000) {
+    async simulateTransaction(config, from, timeout = 15000) {
         try {
             const callParams = {
                 account: from,
@@ -225,66 +286,85 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
         });
         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 };
-    }
-    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) {
-            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.write(fromAddress, config.to, config.value, config.data);
-    }
-    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);
-    }
-    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(1_000_000), 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);
-    }
+    // public async getAllowance(fromTokenAddress: string, walletAddress: string, spenderAddress: string): Promise<AllowanceInfo> {
+    //     const [decimals, allowance] = await Promise.all([
+    //         this.read<string>(fromTokenAddress, erc20TokenAbi, 'decimals'),
+    //         this.read<string>(fromTokenAddress, erc20TokenAbi, 'allowance', [walletAddress, spenderAddress])
+    //     ]);
+    //     const allowanceWeiBN = new BigNumber(allowance);
+    //     const allowanceNonWei = Token.fromWei(allowanceWeiBN, Number(decimals));
+    //     return { allowanceNonWei, allowanceWei: allowanceWeiBN };
+    // }
+    // public encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): EvmTransactionConfig {
+    //     const amountWei = amount ?? new BigNumber(2).pow(256).minus(1).toFixed();
+    //     const tx = EvmAdapter.encodeMethodCall(tokenAddress, erc20TokenAbi, 'approve', [spenderAddress, amountWei]);
+    //     return {
+    //         data: tx.data,
+    //         to: tx.to,
+    //         value: tx.value
+    //     };
+    // }
+    // public async needApprove(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean> {
+    //     // Native coin in METIS can be Token required approve
+    //     if (token.isNative && token.blockchain !== BLOCKCHAIN_NAME.METIS) {
+    //         return false;
+    //     }
+    //     // Special native address for METIS native coin
+    //     const fromTokenAddress =
+    //         token.isNative && token.blockchain === BLOCKCHAIN_NAME.METIS ? '0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000' : token.address;
+    //     const { allowanceWei } = await this.getAllowance(fromTokenAddress, walletAddress, contractAddress);
+    //     return allowanceWei.lt(token.weiAmount);
+    // }
+    // public async approve(fromAddress: string, tokenAddress: string, spenderAddress: string, amount?: string): Promise<string> {
+    //     const config = this.encodeApprove(tokenAddress, spenderAddress, amount);
+    //     return this.write(fromAddress, config.to, config.value, config.data);
+    // }
+    // public async needPermit2Approve(
+    //     token: TokenAmount,
+    //     permit2Address: string,
+    //     walletAddress: string,
+    //     spenderAddress: string
+    // ): Promise<boolean> {
+    //     const res = await this.read<Permit2AllowanceContractResponse>(permit2Address, UNI_V3_PERMIT_2_ABI, 'allowance', [
+    //         walletAddress,
+    //         token.address,
+    //         spenderAddress
+    //     ]);
+    //     const [amount, expiration, _nonce] = res;
+    //     return token.weiAmount.gt(amount) || new BigNumber(Date.now()).gt(Number(expiration) * 1000);
+    // }
+    // public encodePermit2Approve(
+    //     tokenAddress: string,
+    //     spenderAddress: string,
+    //     permit2Address: string,
+    //     expiration: string,
+    //     amount: string
+    // ): EvmTransactionConfig {
+    //     const tx = EvmAdapter.encodeMethodCall(permit2Address, UNI_V3_PERMIT_2_ABI, 'approve', [
+    //         tokenAddress,
+    //         spenderAddress,
+    //         amount,
+    //         expiration
+    //     ]);
+    //     return {
+    //         data: tx.data,
+    //         value: tx.value,
+    //         to: tx.to
+    //     };
+    // }
+    // public async approveOnPermit2(
+    //     fromAddress: string,
+    //     tokenAddress: string,
+    //     permit2Address: string,
+    //     spenderAddress: string,
+    //     deadline: BigNumber = new BigNumber(1_000_000),
+    //     amount?: BigNumber
+    // ): Promise<string> {
+    //     const approveAmount = amount ? amount : new BigNumber(2).pow(256).minus(1);
+    //     const expiration = new BigNumber(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);
+    // }
     /**
      * 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}

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/utils/parse-evm-error.d.ts

@@ -0,0 +1,12 @@
+import { RubicSdkError } from 'packages/web3/src/lib/errors/rubic-sdk.error';
+/**
+ * Type of errors, thrown by web3 methods.
+ */
+export interface Web3Error extends Error {
+    code: number;
+}
+/**
+ * Parses web3 error by its code or message.
+ * @param err Web3 error to parse.
+ */
+export declare function parseEvmError(err: Web3Error): RubicSdkError;

package/src/lib/adapter/adapters/adapter-evm/utils/parse-evm-error.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEvmError = parseEvmError;
+const low_gas_error_1 = require("packages/web3/src/lib/errors/blockchain/low-gas.error");
+const transaction_reverted_error_1 = require("packages/web3/src/lib/errors/blockchain/transaction-reverted.error");
+const user_reject_error_1 = require("packages/web3/src/lib/errors/blockchain/user-reject.error");
+const insufficient_funds_gas_price_value_error_1 = require("packages/web3/src/lib/errors/cross-chain/insufficient-funds-gas-price-value.error");
+const rubic_sdk_error_1 = require("packages/web3/src/lib/errors/rubic-sdk.error");
+const failed_to_check_for_transaction_receipt_error_1 = require("packages/web3/src/lib/errors/swap/failed-to-check-for-transaction-receipt.error");
+const low_slippage_error_1 = require("packages/web3/src/lib/errors/swap/low-slippage.error");
+const proxy_hash_errors_1 = require("../constants/proxy-hash-errors");
+const low_slippage_deflationary_token_error_1 = require("packages/web3/src/lib/errors/swap/low-slippage-deflationary-token.error");
+const errors_1 = require("../../utils/errors");
+/**
+ * Parses web3 error by its code or message.
+ * @param err Web3 error to parse.
+ */
+function parseEvmError(err) {
+    if (err.message.includes('Transaction has been reverted by the EVM')) {
+        return new transaction_reverted_error_1.TransactionRevertedError();
+    }
+    if (err.message.includes('execution reverted: UNIV3R: min return')) {
+        return new low_slippage_error_1.LowSlippageError();
+    }
+    if (err.message.includes('execution reverted: Address: low-level call with value failed') || err.message.includes('Low native value')) {
+        return new insufficient_funds_gas_price_value_error_1.InsufficientFundsGasPriceValueError();
+    }
+    if (err.message.includes('Failed to check for transaction receipt')) {
+        return new failed_to_check_for_transaction_receipt_error_1.FailedToCheckForTransactionReceiptError();
+    }
+    if (err.code === -32603) {
+        return new low_gas_error_1.LowGasError();
+    }
+    if (err.code === 4001 ||
+        err.message.toLowerCase().includes('user denied transaction signature') ||
+        err.message.toLowerCase().includes('user rejected the request')) {
+        return new user_reject_error_1.UserRejectError();
+    }
+    try {
+        const error = tryParseProxyError(err);
+        if (error) {
+            return error;
+        }
+        if (err.message.includes('0x6c544f')) {
+            return new insufficient_funds_gas_price_value_error_1.InsufficientFundsGasPriceValueError();
+        }
+        if (err.message.includes('0xf32bec2f') ||
+            err.message.includes('execution reverted: Received amount of tokens are less then expected') ||
+            err.message.includes('0x275c273c')) {
+            return new low_slippage_deflationary_token_error_1.LowSlippageDeflationaryTokenError();
+        }
+        const errorMessage = JSON.parse(err.message.slice(24)).message;
+        if (errorMessage) {
+            return new Error(errorMessage);
+        }
+    }
+    catch {
+        /* empty */
+    }
+    return (0, errors_1.parseError)(err);
+}
+function tryParseProxyError(err) {
+    if ('data' in err) {
+        const error = proxy_hash_errors_1.proxyHashErrors.find((error) => error.hash === err.data);
+        if (error) {
+            return new rubic_sdk_error_1.RubicSdkError(error.text);
+        }
+    }
+    return undefined;
+}

package/src/lib/adapter/adapters/adapter-solana/client/solana-adapter-client.d.ts

@@ -0,0 +1,15 @@
+import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { SolanaWeb3 } from '../../../constants/models/solana-web3';
+import { RubicAppAdaptersFactoryParams } from '../../../constants/models/create-factory-params';
+import { SolanaSendTxParams } from '../models/solana-send-tx-params';
+import { Connection } from '@solana/web3.js';
+import { AbstractAdapterClient } from '../../common/client/abstract-adapter-client';
+import { TxStatus } from '../../models/web3-public-models/tx-status';
+export declare class SolanaAdapterClient extends AbstractAdapterClient<SolanaWeb3, SolanaSendTxParams, string> {
+    private readonly connection;
+    constructor(connection: Connection, httpClient: HttpClient, logger?: ICustomLogger, rubicAppParams?: RubicAppAdaptersFactoryParams);
+    getBlockchainName(): Promise<BlockchainName>;
+    getTransactionStatus(txHash: string): Promise<TxStatus>;
+    sendTransaction(params: SolanaSendTxParams): Promise<string>;
+    private waitForTxConfirmation;
+}

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaAdapterClient = void 0;
+const core_1 = require("@cryptorubic/core");
+const web3_js_1 = require("@solana/web3.js");
+const waitFor_1 = require("../../utils/waitFor");
+const timeout_error_1 = require("../../../../errors/common/timeout.error");
+const js_base64_1 = require("js-base64");
+const user_reject_error_1 = require("../../../../errors/blockchain/user-reject.error");
+const errors_1 = require("../../utils/errors");
+const abstract_adapter_client_1 = require("../../common/client/abstract-adapter-client");
+const tx_status_1 = require("../../models/web3-public-models/tx-status");
+class SolanaAdapterClient extends abstract_adapter_client_1.AbstractAdapterClient {
+    constructor(connection, httpClient, logger, rubicAppParams) {
+        super(httpClient, logger, rubicAppParams);
+        this.connection = connection;
+    }
+    getBlockchainName() {
+        return Promise.resolve(core_1.BLOCKCHAIN_NAME.SOLANA);
+    }
+    async getTransactionStatus(txHash) {
+        try {
+            const transaction = await this.connection.getTransaction(txHash, {
+                maxSupportedTransactionVersion: 1
+            });
+            if (transaction?.meta?.err) {
+                return tx_status_1.TX_STATUS.FAIL;
+            }
+            if (transaction?.blockTime) {
+                return tx_status_1.TX_STATUS.SUCCESS;
+            }
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+        catch {
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+    }
+    async sendTransaction(params) {
+        try {
+            const decodedData = js_base64_1.Base64.toUint8Array(params.txOptions.data);
+            const tx = web3_js_1.VersionedTransaction.deserialize(decodedData);
+            const signedTx = await this.clientWallet.signTransaction(tx);
+            const txBase64 = js_base64_1.Base64.fromUint8Array(signedTx.serialize());
+            let signature;
+            if (params.txOptions?.sponsorParams) {
+                const response = await this.httpClient.post(`${this.apiUrl}/api/utility/solana/relay`, {
+                    txBase64,
+                    tradeId: params.txOptions.sponsorParams.tradeId
+                });
+                signature = response.signature;
+            }
+            else {
+                try {
+                    const simulation = await this.connection.simulateTransaction(signedTx, {
+                        sigVerify: true,
+                        replaceRecentBlockhash: false
+                    });
+                    console.log(simulation);
+                }
+                catch (err) {
+                    console.log(err);
+                }
+                signature = await this.connection.sendRawTransaction(signedTx.serialize(), {
+                    maxRetries: 3,
+                    skipPreflight: false
+                });
+            }
+            params.txOptions.onTransactionHash?.(signature);
+            await this.waitForTxConfirmation(signature);
+            return signature;
+        }
+        catch (err) {
+            console.error(`[SolanaWeb3Private_sendTransaction] Error: ${err}`, { name: err.name, stack: err.stack });
+            if (err.message.includes('User rejected')) {
+                throw new user_reject_error_1.UserRejectError();
+            }
+            throw (0, errors_1.parseError)(err);
+        }
+    }
+    async waitForTxConfirmation(signature) {
+        const deadline = Date.now() + 3 * 60 * 1000;
+        let fetchedTx = null;
+        while (!fetchedTx && Date.now() < deadline) {
+            await (0, waitFor_1.waitFor)(5000);
+            fetchedTx = await this.connection.getTransaction(signature, {
+                commitment: 'confirmed',
+                maxSupportedTransactionVersion: 1
+            });
+        }
+        if (!fetchedTx || fetchedTx.meta?.err)
+            throw new timeout_error_1.TimeoutError();
+    }
+}
+exports.SolanaAdapterClient = SolanaAdapterClient;

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

@@ -0,0 +1,16 @@
+import { BasicSendTransactionOptions } from '../../models/basic-transaction-options';
+export interface SolanaSendTxParams {
+    txOptions: SolanaTransactionOptions;
+    calculateConsumedParams?: boolean;
+    additionalData?: string[];
+}
+export interface SolanaTransactionOptions extends BasicSendTransactionOptions {
+    /**
+     * Encoded data, which will be executed in transaction.
+     */
+    data?: string;
+    sponsorParams?: {
+        tradeId: string;
+        feePayer: string;
+    };
+}

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

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

package/src/lib/adapter/adapters/{utils/solana-utils → adapter-solana/services}/solana-tokens-service.js

@@ -3,18 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaTokensService = void 0;
 const spl_token_1 = require("@solana/spl-token");
 const utl_sdk_1 = require("@solflare-wallet/utl-sdk");
-const timeout_1 = require("../timeout");
+const timeout_1 = require("../../utils/timeout");
 class SolanaTokensService {
-    httpClient;
-    connection;
-    // key - address of token, value - idx of token in initial tokensAddress
-    tokensOrder = {};
-    initialMints = [];
-    apiEndpoint = 'https://x-api.rubic.exchange/sol_token_list';
-    newTokensEndpoint = 'https://api.rubic.exchange/api/v2';
-    xApiKey = 'sndfje3u4b3fnNSDNFUSDNVSunw345842hrnfd3b4nt4';
     constructor(connection, httpClient) {
         this.httpClient = httpClient;
+        // key - address of token, value - idx of token in initial tokensAddress
+        this.tokensOrder = {};
+        this.initialMints = [];
+        this.apiEndpoint = 'https://x-api.rubic.exchange/sol_token_list';
+        this.newTokensEndpoint = 'https://api.rubic.exchange/api/v2';
+        this.xApiKey = 'sndfje3u4b3fnNSDNFUSDNVSunw345842hrnfd3b4nt4';
         this.connection = connection;
     }
     async fetchTokensData(mints) {
@@ -59,7 +57,7 @@ class SolanaTokensService {
     }
     async fetchTokensFromOldBackend(mints, prevFetchedTokens) {
         const tokensAddresses = mints.map((mint) => mint.toString());
-        const { content: tokensFromOlbBackend } = await (0, timeout_1.withTimeout)(this.getTokensListOld(tokensAddresses), 3_000, 'Api Timeout!').catch(() => ({ content: [] }));
+        const { content: tokensFromOlbBackend } = await (0, timeout_1.withTimeout)(this.getTokensListOld(tokensAddresses), 3000, 'Api Timeout!').catch(() => ({ content: [] }));
         const notSortedTokensList = [...prevFetchedTokens, ...tokensFromOlbBackend];
         const notFetchedMints = this.getNotFetchedTokensList(notSortedTokensList);
         return {