@cryptorubic/web3 0.8.17-alpha.solana.2 → 0.8.17-alpha.solana.20

package/package.json

@@ -1,27 +1,26 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "0.8.17-alpha.solana.2",
+    "version": "0.8.17-alpha.solana.20",
     "dependencies": {
-        "tslib": "^2.3.0",
-        "bignumber.js": "9.1.2",
-        "@cryptorubic/core": "0.8.17-alpha.solana.2",
-        "viem": "^2.19.1",
-        "web3-utils": "^4.3.1",
-        "@ton/ton": "^15.1.0",
+        "@ethersproject/bignumber": "^5.8.0",
+        "@mysten/sui": "^1.24.0",
+        "@solana/spl-token": "*",
         "@solana/web3.js": "1.95.3",
         "@solflare-wallet/utl-sdk": "^1.4.0",
-        "@ethersproject/bignumber": "^5.7.0",
-        "@cryptorubic/tron-types": "0.8.17-alpha.solana.2",
+        "@suiet/wallet-sdk": "^0.3.3",
+        "@ton/ton": "^15.1.0",
+        "axios": "*",
+        "bignumber.js": "9.1.2",
         "bitcoin-address-validation": "^2.2.3",
-        "axios": "0.27.2",
+        "bs58": "^6.0.0",
         "crc-32": "^1.2.2",
+        "ethers": "*",
+        "js-base64": "^3.7.8",
         "tronweb": "^6.0.0-beta.4",
-        "@solana/spl-token": "0.2.0",
-        "@mysten/sui": "^1.24.0",
-        "@suiet/wallet-sdk": "^0.3.3",
-        "bs58": "^6.0.0",
-        "ethers": "5.7.2"
+        "tslib": "*",
+        "viem": "^2.33.1"
     },
+    "peerDependencies": {},
     "type": "commonjs",
     "main": "./src/index.js",
     "typings": "./src/index.d.ts",
@@ -31,5 +30,12 @@
     "author": {
         "name": "Sleta Dmitrii"
     },
+    "exports": {
+        "./package.json": "./package.json",
+        ".": {
+            "types": "./src/index.d.ts",
+            "default": "./src/index.js"
+        }
+    },
     "types": "./src/index.d.ts"
 }

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

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractAdapter = void 0;
 const viem_1 = require("viem");
 class AbstractAdapter {
+    logger;
+    blockchain;
+    _public = null;
     set public(value) {
         this._public = value;
     }
@@ -14,6 +17,7 @@ class AbstractAdapter {
         }
         return this._public;
     }
+    _wallet = null;
     set wallet(value) {
         this._wallet = value;
     }
@@ -25,6 +29,7 @@ class AbstractAdapter {
         }
         return this._wallet;
     }
+    _walletAddress = null;
     set walletAddress(value) {
         this._walletAddress = value;
     }
@@ -37,9 +42,6 @@ class AbstractAdapter {
         return this._walletAddress;
     }
     constructor(blockchain, logger) {
-        this._public = null;
-        this._wallet = null;
-        this._walletAddress = null;
         this.blockchain = blockchain;
         if (logger) {
             this.logger = logger;

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

@@ -5,6 +5,7 @@ const core_1 = require("@cryptorubic/core");
 const bignumber_js_1 = require("bignumber.js");
 const abstract_adapter_1 = require("./abstract-adapter");
 class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
+    httpClient;
     constructor(httpClient, logger) {
         super(core_1.BLOCKCHAIN_NAME.BITCOIN, logger);
         this.httpClient = httpClient;

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

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

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

@@ -34,21 +34,22 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             return null;
         }
         const transports = rpcList.map((rpc) => (0, viem_1.http)(rpc, {
-            batch: { batchSize: 2000, wait: 16 },
+            batch: { batchSize: 2_000, wait: 16 },
             onFetchResponse: (response) => {
                 this.handlePossibleError(response);
             },
             retryCount: 2,
             retryDelay: 100,
-            timeout: 5000
+            timeout: 5_000
         }));
         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: 1800000
+                    interval: 1_800_000
                 }
             })
         });
@@ -80,7 +81,8 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             to: to,
             value: (0, viem_1.parseEther)(value),
             data: data,
-            chain: this.public.chain
+            chain: this.public.chain,
+            kzg: undefined
         });
         return result;
     }
@@ -135,7 +137,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             throw err;
         }
     }
-    async simulateTransaction(config, from, timeout = 15000) {
+    async simulateTransaction(config, from, timeout = 15_000) {
         try {
             const callParams = {
                 account: from,
@@ -278,7 +280,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             to: tx.to
         };
     }
-    async approveOnPermit2(fromAddress, tokenAddress, permit2Address, spenderAddress, deadline = new bignumber_js_1.default(1000000), amount) {
+    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());

package/src/lib/adapter/adapters/models/approve-adapter.d.ts

@@ -2,7 +2,7 @@ import { BlockchainName, TokenAmount } from '@cryptorubic/core';
 import { AllowanceInfo } from './common-types';
 import { AbstractAdapter } from '../abstract-adapter';
 import { EvmTransactionConfig } from '../../../utils/models/evm-transaction-config';
-import { TronTransactionConfig } from '@cryptorubic/tron-types';
+import { TronTransactionConfig } from '../../../utils/models/tron-transaction-config';
 export interface ApproveAdapter<T> extends AbstractAdapter<any, any, BlockchainName> {
     /**
      * @param fromTokenAddress erc20 address of checked token

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

@@ -1,17 +1,17 @@
 import { Abi, MulticallResponse, MulticallParameters } from 'viem';
 import { AbstractAdapter } from './abstract-adapter';
-import { AddressLookupTableAccount, Connection, Keypair, PublicKey, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
+import { AddressLookupTableAccount, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
 import { HttpClient, ICustomLogger, PriceTokenAmount, SolanaBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
 import BigNumber from 'bignumber.js';
 import { SolanaRawInstruction } from './models/solana-web3-types';
 import { SolanaTxConfig } from '../../utils/models/solana-transaction-config';
-import { SolanaApiService } from './utils/solana-api-service';
 import { SolanaAdapterConfig } from './models/solana-adapter-config';
+import { SolanaGasService } from './utils/solana-utils/solana-gas-service';
 export declare const NATIVE_SOLANA_MINT_ADDRESS = "So11111111111111111111111111111111111111111";
 export declare const DEFAULT_CU_LIMIT = 600000;
 export declare class SolanaAdapter extends AbstractAdapter<Connection, Connection, SolanaBlockchainName> {
     private readonly httpClient;
-    readonly apiService: SolanaApiService;
+    readonly gasService: SolanaGasService;
     constructor(rpcList: string[], httpClient: HttpClient, solanaConfig: SolanaAdapterConfig, logger?: ICustomLogger);
     private createPublicClient;
     read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
@@ -36,4 +36,8 @@ export declare class SolanaAdapter extends AbstractAdapter<Connection, Connectio
     getTxWithPayer(tx: VersionedTransaction, feePayer: string): Promise<VersionedTransaction>;
     deserializeTransaction(data: string): VersionedTransaction;
     serializeTransactionToBase58(tx: VersionedTransaction): string;
+    createTransferData(fromToken: PriceTokenAmount, walletAddress: string, receiver: string, convertToVersionedTx: boolean): Promise<Transaction | VersionedTransaction>;
+    createNativeTransfer(fromAddress: PublicKey, toAddress: PublicKey, fromWeiAmount: string): Transaction;
+    createTokenTransfer(fromAddress: PublicKey, toAddress: PublicKey, fromTokenAddress: string, fromWeiAmount: string): Promise<Transaction>;
+    getLatestBlockhash(): Promise<string>;
 }

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

@@ -7,18 +7,21 @@ const web3_js_1 = require("@solana/web3.js");
 const core_1 = require("@cryptorubic/core");
 const web3_pure_1 = require("../../utils/web3-pure");
 const bignumber_js_1 = require("bignumber.js");
-const solana_tokens_service_1 = require("./utils/solana-tokens-service");
 const bs58_1 = require("bs58");
-const utils_1 = require("ethers/lib/utils");
-const solana_api_service_1 = require("./utils/solana-api-service");
+const js_base64_1 = require("js-base64");
+const solana_gas_service_1 = require("./utils/solana-utils/solana-gas-service");
+const solana_tokens_service_1 = require("./utils/solana-utils/solana-tokens-service");
+const timeout_1 = require("./utils/timeout");
 exports.NATIVE_SOLANA_MINT_ADDRESS = 'So11111111111111111111111111111111111111111';
-exports.DEFAULT_CU_LIMIT = 600000;
+exports.DEFAULT_CU_LIMIT = 600_000;
 class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
+    httpClient;
+    gasService;
     constructor(rpcList, httpClient, solanaConfig, logger) {
         super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
         this.httpClient = httpClient;
         this.public = this.createPublicClient(rpcList);
-        this.apiService = new solana_api_service_1.SolanaApiService(httpClient, this.public, solanaConfig);
+        this.gasService = new solana_gas_service_1.SolanaGasService(httpClient, this.public, logger, solanaConfig);
     }
     createPublicClient(rpcList) {
         if (!rpcList?.[0]) {
@@ -41,22 +44,14 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
     async multicallByAddress(_address, _abi, _method, _methodArgs = [], _allowErrors = true) {
         throw new Error('Method multicall is not supported');
     }
-    async simulateTransaction(config, timeout = 15000) {
+    async simulateTransaction(config, timeout = 15_000) {
         try {
             const bufferData = config.data.startsWith('0x') ? Buffer.from(config.data.slice(2), 'hex') : Buffer.from(config.data, 'base64');
             const { blockhash } = await this.public.getLatestBlockhash();
             const tx = web3_js_1.VersionedTransaction.deserialize(bufferData);
             tx.message.recentBlockhash = blockhash;
-            const simulation = this.public.simulateTransaction(tx, {
-                commitment: 'finalized',
-                replaceRecentBlockhash: false,
-                sigVerify: true,
-                accounts: { encoding: 'base64', addresses: [...Object.values(config.accounts)] }
-            });
-            const resp = await Promise.race([
-                simulation,
-                new Promise((_, reject) => setTimeout(() => reject('Timeout'), timeout))
-            ]);
+            const simulation = this.public.simulateTransaction(tx, { replaceRecentBlockhash: true });
+            const resp = await (0, timeout_1.withTimeout)(simulation, timeout, 'Solana Simulation Timeout!');
             return new bignumber_js_1.default(resp.value.unitsConsumed || exports.DEFAULT_CU_LIMIT).toFixed(0);
         }
         catch (err) {
@@ -139,7 +134,7 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
         return accounts.filter((v) => !!v);
     }
     async createVersionedTransaction(instructions, walletAddress, addressLookupTableAccounts = []) {
-        const { blockhash } = await this.public.getLatestBlockhash();
+        const blockhash = await this.getLatestBlockhash();
         const message = new web3_js_1.TransactionMessage({
             instructions,
             payerKey: new web3_js_1.PublicKey(walletAddress),
@@ -181,11 +176,53 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
         return new web3_js_1.VersionedTransaction(newMsg);
     }
     deserializeTransaction(data) {
-        const decodedData = data.startsWith('0x') ? Buffer.from(data.slice(2), 'hex') : utils_1.base64.decode(data);
+        const decodedData = data.startsWith('0x') ? Buffer.from(data.slice(2), 'hex') : js_base64_1.Base64.toUint8Array(data);
         return web3_js_1.VersionedTransaction.deserialize(decodedData);
     }
     serializeTransactionToBase58(tx) {
         return bs58_1.default.encode(tx.serialize());
     }
+    async createTransferData(fromToken, walletAddress, receiver, convertToVersionedTx) {
+        const fromAddress = new web3_js_1.PublicKey(walletAddress);
+        const toAddress = new web3_js_1.PublicKey(receiver);
+        const transaction = fromToken.isNative
+            ? this.createNativeTransfer(fromAddress, toAddress, fromToken.stringWeiAmount)
+            : await this.createTokenTransfer(fromAddress, toAddress, fromToken.address, fromToken.stringWeiAmount);
+        if (convertToVersionedTx) {
+            const blockhash = await this.getLatestBlockhash();
+            const message = new web3_js_1.TransactionMessage({
+                payerKey: fromAddress,
+                recentBlockhash: blockhash,
+                instructions: transaction.instructions
+            }).compileToV0Message();
+            return new web3_js_1.VersionedTransaction(message);
+        }
+        return transaction;
+    }
+    createNativeTransfer(fromAddress, toAddress, fromWeiAmount) {
+        return new web3_js_1.Transaction().add(web3_js_1.SystemProgram.transfer({
+            fromPubkey: fromAddress,
+            toPubkey: toAddress,
+            lamports: BigInt(fromWeiAmount)
+        }));
+    }
+    async createTokenTransfer(fromAddress, toAddress, fromTokenAddress, fromWeiAmount) {
+        const mintTokenAccount = new web3_js_1.PublicKey(fromTokenAddress);
+        const [fromATA, toATA] = await Promise.all([
+            (0, spl_token_1.getAssociatedTokenAddress)(mintTokenAccount, fromAddress),
+            (0, spl_token_1.getAssociatedTokenAddress)(mintTokenAccount, toAddress)
+        ]);
+        const transaction = new web3_js_1.Transaction();
+        const receiverAccountInfo = await this.public.getAccountInfo(toATA);
+        if (!receiverAccountInfo) {
+            transaction.add((0, spl_token_1.createAssociatedTokenAccountInstruction)(fromAddress, toATA, toAddress, mintTokenAccount));
+        }
+        transaction.add((0, spl_token_1.createTransferInstruction)(fromATA, toATA, fromAddress, BigInt(fromWeiAmount)));
+        return transaction;
+    }
+    async getLatestBlockhash() {
+        const { blockhash } = await this.public.getLatestBlockhash();
+        return blockhash;
+    }
 }
 exports.SolanaAdapter = SolanaAdapter;

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

@@ -8,6 +8,8 @@ const bignumber_js_1 = require("bignumber.js");
 const abstract_adapter_1 = require("./abstract-adapter");
 const web3_pure_1 = require("../../utils/web3-pure");
 class TonAdapter extends abstract_adapter_1.AbstractAdapter {
+    tonApi;
+    tonClient;
     constructor(httpClient, config, logger) {
         super(core_1.BLOCKCHAIN_NAME.TON, logger);
         this.tonApi = new ton_api_service_1.TonApiService(httpClient, config.tonApiConfig);

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

@@ -1,25 +1,26 @@
 import BigNumber from 'bignumber.js';
 import { AbstractAdapter } from './abstract-adapter';
-import { ContractMulticallResponse, MethodData, TronWeb3PrimitiveType } from '@cryptorubic/tron-types';
 import { TronWeb } from 'tronweb';
-import { AbiFragment } from 'tronweb/lib/commonjs/types';
 import { ICustomLogger, PriceTokenAmount, Token, TokenAmount, TronBlockchainName } from '@cryptorubic/core';
 import { TronTransactionConfig } from '../../utils/models/tron-transaction-config';
 import { TronParameters } from '../../utils/models/tron-parameters';
 import { Abi } from 'viem';
 import { ApproveAdapter } from './models/approve-adapter';
 import { AllowanceInfo } from './models/common-types';
+import { ContractMulticallResponse } from '../../utils/models/contract-multicall-response';
+import { TronWeb3PrimitiveType } from '../../utils/models/primitive-types';
+import { MethodData } from '../../utils/models/method-data';
 export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> implements ApproveAdapter<TronTransactionConfig> {
     private readonly multicallAddress;
     needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
     constructor(rpcList: string[], logger?: ICustomLogger);
     checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
-    multicallContractsMethods<Output extends TronWeb3PrimitiveType>(contractAbi: readonly AbiFragment[], contractsData: {
+    multicallContractsMethods<Output extends TronWeb3PrimitiveType>(contractAbi: any, contractsData: {
         contractAddress: string;
         methodsData: MethodData[];
-    }[]): Promise<ContractMulticallResponse<Output>[][]>;
+    }[]): Promise<ContractMulticallResponse<any>[][]>;
     private multicall;
-    read<T>(contractAddress: string, contractAbi: readonly AbiFragment[], methodName: string, methodArguments?: unknown[]): Promise<T>;
+    read<T>(contractAddress: string, contractAbi: any, methodName: string, methodArguments?: unknown[]): Promise<T>;
     private multicallContractsMethodsByOne;
     getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token[]>;

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

@@ -10,13 +10,13 @@ const core_1 = require("@cryptorubic/core");
 const web3_pure_1 = require("../../utils/web3-pure");
 const tron_web3_pure_1 = require("../../utils/web3-types/tron-web3-pure");
 class TronAdapter extends abstract_adapter_1.AbstractAdapter {
+    multicallAddress = 'T9ziQU4EBteJzjzMzhHELdhgWFqwzS5Vki';
     async needPreswapAction(token, contractAddress, walletAddress, amount) {
         // return this.needApprove()
         return false;
     }
     constructor(rpcList, logger) {
         super(core_1.BLOCKCHAIN_NAME.TRON, logger);
-        this.multicallAddress = 'T9ziQU4EBteJzjzMzhHELdhgWFqwzS5Vki';
         this.public = new tronweb_1.TronWeb({ fullHost: rpcList[0] });
     }
     async checkEnoughBalance(token, walletAddress) {

package/src/lib/adapter/adapters/utils/solana-utils/solana-gas-service.d.ts

@@ -0,0 +1,27 @@
+import { HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { Connection } from '@solana/web3.js';
+import { SolanaAdapterConfig } from '../../models/solana-adapter-config';
+import BigNumber from 'bignumber.js';
+export declare class SolanaGasService {
+    private httpClient;
+    private readonly connection;
+    private readonly logger;
+    private readonly HELIUS_API_URL;
+    private readonly HELIUS_API_KEY;
+    readonly DEFAULT_CU_LIMIT = 200000;
+    constructor(httpClient: HttpClient, connection: Connection, logger: ICustomLogger | undefined, solanaConfig: SolanaAdapterConfig);
+    /**
+     * @returns wei ComputedUnitsLimit - like gasLimit in evm
+     */
+    getConsumedUnitsLimit(txData: string): Promise<BigNumber>;
+    /**
+     * @param txData base64 or hex string
+     * @returns prioritizationFee in micro-lamports (lamport = 1_000_000 microlamports)
+     */
+    getPriorityFee(txData: string): Promise<BigNumber>;
+    /**
+     * @returns consumedUnitsPrice in micro-lamports(lamport * 10^-6)
+     */
+    private calculatePriorityFeeHelius;
+    private getRecentPriorityFeeSolWeb3;
+}

package/src/lib/adapter/adapters/utils/solana-utils/solana-gas-service.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaGasService = void 0;
+const utils_1 = require("ethers/lib/utils");
+const utility_funcs_1 = require("./utility-funcs");
+const bignumber_js_1 = require("bignumber.js");
+// solana gas fee FORMULA: 200_000 CU * 0.02 Lamports/CU = 4000 Lamports = 0.000004 SOL
+class SolanaGasService {
+    httpClient;
+    connection;
+    logger;
+    HELIUS_API_URL = 'https://mainnet.helius-rpc.com';
+    HELIUS_API_KEY;
+    DEFAULT_CU_LIMIT = 200_000; //in CU
+    constructor(httpClient, connection, logger, solanaConfig) {
+        this.httpClient = httpClient;
+        this.connection = connection;
+        this.logger = logger;
+        this.HELIUS_API_KEY = solanaConfig.heliusApiKey;
+    }
+    /**
+     * @returns wei ComputedUnitsLimit - like gasLimit in evm
+     */
+    async getConsumedUnitsLimit(txData) {
+        try {
+            const tx = (0, utility_funcs_1.convertB64DataToTx)(txData);
+            const resp = await this.connection.simulateTransaction(tx, {
+                replaceRecentBlockhash: true
+            });
+            return resp.value.unitsConsumed ? new bignumber_js_1.default(resp.value.unitsConsumed * 1.2) : new bignumber_js_1.default(this.DEFAULT_CU_LIMIT);
+        }
+        catch (err) {
+            console.error('[SolanaApiService_getConsumedUnitsLimit] err ==> ', err);
+            return new bignumber_js_1.default(this.DEFAULT_CU_LIMIT);
+        }
+    }
+    /**
+     * @param txData base64 or hex string
+     * @returns prioritizationFee in micro-lamports (lamport = 1_000_000 microlamports)
+     */
+    async getPriorityFee(txData) {
+        if (!this.HELIUS_API_KEY) {
+            console.warn('[SolanaApiService_getConsumedUnitsPrice] heliusApiKey is not provided in "createFactory"');
+        }
+        const resp = await Promise.allSettled([this.calculatePriorityFeeHelius(txData), this.getRecentPriorityFeeSolWeb3()]);
+        const cuPrice = resp
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value)
+            .reduce((acc, price) => (acc.gt(price) ? acc : price), new bignumber_js_1.default(0));
+        return cuPrice;
+    }
+    /**
+     * @returns consumedUnitsPrice in micro-lamports(lamport * 10^-6)
+     */
+    async calculatePriorityFeeHelius(txData) {
+        try {
+            const tx = (0, utility_funcs_1.convertB64DataToTx)(txData);
+            const resp = await this.httpClient.post(`${this.HELIUS_API_URL}/?api-key=${this.HELIUS_API_KEY}`, {
+                jsonrpc: '2.0',
+                id: '1',
+                method: 'getPriorityFeeEstimate',
+                params: [
+                    {
+                        transaction: utils_1.base58.encode(tx.serialize()), // Pass the serialized transaction in Base58
+                        options: { priorityLevel: 'Medium' }
+                    }
+                ]
+            });
+            this.logger?.customLog('HELIUS PRIORITY_FEE SUCCESS', { priorityFeeEstimate: resp.result.priorityFeeEstimate });
+            return new bignumber_js_1.default(resp.result.priorityFeeEstimate);
+        }
+        catch (err) {
+            this.logger?.customLog('HELIUS PRIORITY_FEE ERROR', err);
+            return new bignumber_js_1.default(0);
+        }
+    }
+    async getRecentPriorityFeeSolWeb3() {
+        const BASE_FEE_MICROLAMPORTS = 5_000;
+        const lastSlot = await this.connection.getSlot();
+        // last slots array [1000, 1001, 1002 ...]
+        const last10Slots = Array.from({ length: 10 }, (_, idx) => lastSlot - idx).reverse();
+        const getPriorityFeesFromBlock = async (slotNum) => {
+            const block = await this.connection.getBlock(slotNum, { maxSupportedTransactionVersion: 0, commitment: 'confirmed' });
+            if (!block)
+                return [];
+            return block.transactions.map((tx) => (tx.meta && tx.meta.fee ? tx.meta.fee : BASE_FEE_MICROLAMPORTS));
+        };
+        const resp = await Promise.all(last10Slots.map((slotNum) => getPriorityFeesFromBlock(slotNum)));
+        const flattenPriorityFees = resp.flat();
+        const avgProrityFee = flattenPriorityFees
+            .reduce((acc, fee) => acc.plus(fee), new bignumber_js_1.default(0))
+            .div(flattenPriorityFees.length)
+            .dp(0, bignumber_js_1.default.ROUND_CEIL);
+        // const resp = await this.connection.getRecentPrioritizationFees();
+        // const avgPriorityFee = resp
+        //     .reduce((acc, tx) => {
+        //         const cuPrice = new BigNumber(tx.prioritizationFee).multipliedBy(1_000_000).div(this.DEFAULT_CU_LIMIT);
+        //         return acc.gt(cuPrice) ? acc : cuPrice;
+        //     }, new BigNumber(0))
+        //     .div(resp.length)
+        //     .dp(0, BigNumber.ROUND_CEIL);
+        this.logger?.customLog('SOLANA_WEB3 PRIORITY_FEE SUCCESS', { priorityFeeEstimate: avgProrityFee.toNumber(), flattenPriorityFees });
+        return avgProrityFee;
+    }
+}
+exports.SolanaGasService = SolanaGasService;

package/src/lib/adapter/adapters/utils/{solana-tokens-service.d.ts → solana-utils/solana-tokens-service.d.ts}

@@ -1,6 +1,6 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import { HttpClient } from '@cryptorubic/core';
-import { SolanaToken } from '../models/solana-web3-types';
+import { SolanaToken } from '../../models/solana-web3-types';
 export declare class SolanaTokensService {
     private readonly httpClient;
     private connection;

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

@@ -3,16 +3,18 @@ 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("../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) {
@@ -57,7 +59,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), 3000, 'Api Timeout!').catch(() => ({ content: [] }));
+        const { content: tokensFromOlbBackend } = await (0, timeout_1.withTimeout)(this.getTokensListOld(tokensAddresses), 3_000, 'Api Timeout!').catch(() => ({ content: [] }));
         const notSortedTokensList = [...prevFetchedTokens, ...tokensFromOlbBackend];
         const notFetchedMints = this.getNotFetchedTokensList(notSortedTokensList);
         return {

package/src/lib/adapter/adapters/utils/solana-utils/utility-funcs.d.ts

@@ -0,0 +1,2 @@
+import { VersionedTransaction } from '@solana/web3.js';
+export declare function convertB64DataToTx(txData: string): VersionedTransaction;

package/src/lib/adapter/adapters/utils/solana-utils/utility-funcs.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertB64DataToTx = convertB64DataToTx;
+const web3_js_1 = require("@solana/web3.js");
+function convertB64DataToTx(txData) {
+    const bufferData = txData.startsWith('0x') ? Buffer.from(txData.slice(2), 'hex') : Buffer.from(txData, 'base64');
+    const tx = web3_js_1.VersionedTransaction.deserialize(bufferData);
+    return tx;
+}

package/src/lib/adapter/adapters/utils/ton-api.service.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TonApiService = void 0;
 class TonApiService {
+    httpClient;
+    tonApiUrl;
+    apiKey;
+    tonCenterV3Url;
     constructor(httpClient, params) {
         this.httpClient = httpClient;
         this.apiKey = params.tonApiKey;

package/src/lib/adapter/blockchain-adapter-factory.service.js

@@ -11,10 +11,13 @@ const evm_adapter_1 = require("./adapters/evm-adapter");
 const bitcoin_adapter_1 = require("./adapters/bitcoin-adapter");
 const sui_adapter_1 = require("./adapters/sui-adapter");
 class BlockchainAdapterFactoryService {
+    rpcList;
+    params;
+    adapterStore = {};
+    logger;
     constructor(rpcList, params) {
         this.rpcList = rpcList;
         this.params = params;
-        this.adapterStore = {};
         this.adapterStore = this.createStorage();
         if (this.params.createLogger) {
             this.logger = this.params.createLogger('BlockchainAdapterFactory');

package/src/lib/utils/models/solana-transaction-config.d.ts

@@ -1,11 +1,5 @@
 type Base64String = `AQA${string}`;
 export interface SolanaTxConfig {
     data: Base64String;
-    accounts: {
-        walletAddress?: string;
-        fromATA?: string;
-        toATA?: string;
-    };
-    estimateConsumedUnits?: boolean;
 }
 export {};

package/src/lib/utils/web3-types/common-web3-pure.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonWeb3Pure = void 0;
 const axios_1 = require("axios");
 class CommonWeb3Pure {
+    nativeTokenAddress = '0x0000000000000000000000000000000000000000';
+    emptyAddress = '0x0000000000000000000000000000000000000000';
+    cnApiKey;
+    regEx;
     constructor(commonParams) {
-        this.nativeTokenAddress = '0x0000000000000000000000000000000000000000';
-        this.emptyAddress = '0x0000000000000000000000000000000000000000';
         this.cnApiKey = commonParams?.cnApiKey || undefined;
         this.regEx = commonParams?.regex || undefined;
     }

package/src/lib/utils/web3-types/solana-web3-pure.js

@@ -5,12 +5,12 @@ const changenow_api_blockchain_1 = require("../constants/changenow-api-blockchai
 const common_web3_pure_1 = require("./common-web3-pure");
 const core_1 = require("@cryptorubic/core");
 class SolanaWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
+    nativeTokenAddress = 'So11111111111111111111111111111111111111111';
     constructor() {
         super({
             cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.SOLANA,
             regex: /^(?!.*([1-9A-HJ-NP-Za-km-z])\1{31,43}$)[1-9A-HJ-NP-Za-km-z]{32,44}$/
         });
-        this.nativeTokenAddress = 'So11111111111111111111111111111111111111111';
     }
     async isAddressCorrect(address) {
         if ((0, core_1.compareAddresses)(address, this.nativeTokenAddress)) {

package/src/lib/utils/web3-types/sui-web3-pure.js

@@ -5,6 +5,8 @@ const common_web3_pure_1 = require("./common-web3-pure");
 const core_1 = require("@cryptorubic/core");
 const bignumber_js_1 = require("bignumber.js");
 class SuiWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
+    nativeTokenAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+    emptyAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
     static compareAddress(addressA, addressB) {
         const pureAddressA = addressA.split(':')[0];
         const pureAddressB = addressB.split(':')[0];
@@ -20,8 +22,6 @@ class SuiWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
         super({
             regex: /(^0[xX][a-fA-F0-9]{0,64}::[a-zA-Z0-9_]*::[A-Z0-9_]*$)|(^0[xX][a-fA-F0-9]{64}$)/
         });
-        this.nativeTokenAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
-        this.emptyAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
     }
 }
 exports.SuiWeb3Pure = SuiWeb3Pure;

package/src/lib/utils/web3-types/tron-web3-pure.d.ts

@@ -2,7 +2,6 @@ import { CommonWeb3Pure } from './common-web3-pure';
 import { TronTransactionConfig } from '../models/tron-transaction-config';
 import { TronParameters } from '../models/tron-parameters';
 import { TronWeb3PrimitiveType, Web3PrimitiveType } from '../models/primitive-types';
-import { FunctionFragment } from 'tronweb/src/types/ABI';
 import { AbiItem } from '../models/abi-types';
 export declare class TronWeb3Pure extends CommonWeb3Pure {
     constructor();
@@ -16,7 +15,7 @@ export declare class TronWeb3Pure extends CommonWeb3Pure {
      * @param methodArguments Parameters to encode.
      * @returns An ABI encoded function call. Means function signature + parameters.
      */
-    static encodeFunctionCall(contractAbi: FunctionFragment[], methodName: string, methodArguments: unknown[]): string;
+    static encodeFunctionCall(contractAbi: any[], methodName: string, methodArguments: unknown[]): string;
     static encodeMethodSignature(methodSignature: string, parameters: TronParameters): string;
     /**
      * Decodes method result using its JSON interface object and given parameters.
@@ -24,7 +23,7 @@ export declare class TronWeb3Pure extends CommonWeb3Pure {
      * @param response Bytes code returned after method call.
      * @returns Parsed method output.
      */
-    static decodeMethodOutput(outputAbi: FunctionFragment[], response: string): Web3PrimitiveType;
+    static decodeMethodOutput(outputAbi: any[], response: string): Web3PrimitiveType;
     private static flattenTypesToString;
     private static flattenTypesToArray;
     private static flattenParameters;

package/src/lib/adapter/adapters/utils/solana-api-service.d.ts

@@ -1,18 +0,0 @@
-import { HttpClient } from '@cryptorubic/core';
-import { Connection, VersionedTransaction } from '@solana/web3.js';
-import { SolanaAdapterConfig } from '../models/solana-adapter-config';
-export declare class SolanaApiService {
-    private httpClient;
-    private readonly connection;
-    private readonly HELIUS_API_URL;
-    private readonly HELIUS_API_KEY;
-    constructor(httpClient: HttpClient, connection: Connection, solanaConfig: SolanaAdapterConfig);
-    /**
-     * @returns ComputedUnitsLimit - like gasLimit in evm
-     */
-    getConsumedUnitsLimit(tx: VersionedTransaction): Promise<number>;
-    /**
-     * @returns ComputedUnitsPrice - like gasPrice in evm
-     */
-    getConsumedUnitsPrice(tx: VersionedTransaction): Promise<number>;
-}

package/src/lib/adapter/adapters/utils/solana-api-service.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaApiService = void 0;
-const utils_1 = require("ethers/lib/utils");
-class SolanaApiService {
-    constructor(httpClient, connection, solanaConfig) {
-        this.httpClient = httpClient;
-        this.connection = connection;
-        this.HELIUS_API_URL = 'https://mainnet.helius-rpc.com';
-        this.HELIUS_API_KEY = solanaConfig.heliusApiKey;
-    }
-    /**
-     * @returns ComputedUnitsLimit - like gasLimit in evm
-     */
-    async getConsumedUnitsLimit(tx) {
-        const DEFAULT_CU_LIMIT = 600000;
-        try {
-            const resp = await this.connection.simulateTransaction(tx, {
-                replaceRecentBlockhash: true
-            });
-            return resp.value.unitsConsumed ? resp.value.unitsConsumed * 1.2 : DEFAULT_CU_LIMIT;
-        }
-        catch (err) {
-            console.error('Solana_simulateTransaction_Error ==> ', err);
-            return DEFAULT_CU_LIMIT;
-        }
-    }
-    /**
-     * @returns ComputedUnitsPrice - like gasPrice in evm
-     */
-    async getConsumedUnitsPrice(tx) {
-        if (!this.HELIUS_API_KEY) {
-            throw new Error('[SolanaApiService_getConsumedUnitsPrice] params.solanaParams.heliusApiKey is not provided in "createFactory" method to use this method');
-        }
-        const resp = await this.httpClient.post(`${this.HELIUS_API_URL}/?api-key=${this.HELIUS_API_KEY}`, {
-            jsonrpc: '2.0',
-            id: '1',
-            method: 'getPriorityFeeEstimate',
-            params: [
-                {
-                    transaction: utils_1.base58.encode(tx.serialize()), // Pass the serialized transaction in Base58
-                    options: { priorityLevel: 'Medium' }
-                }
-            ]
-        });
-        return resp.result.priorityFeeEstimate;
-    }
-}
-exports.SolanaApiService = SolanaApiService;