@cryptorubic/web3 0.8.17-alpha.solana.15 → 0.8.17-alpha.solana.17

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "0.8.17-alpha.solana.15",
+    "version": "0.8.17-alpha.solana.17",
     "dependencies": {
         "@ethersproject/bignumber": "^5.8.0",
         "@mysten/sui": "^1.24.0",

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

@@ -19,8 +19,6 @@ export declare class SolanaAdapter extends AbstractAdapter<Connection, Connectio
     multicallByContract<T>(_contracts: MulticallParameters, _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
     multicallByAddress<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[][], _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
     simulateTransaction(config: SolanaTxConfig, timeout?: number): Promise<string>;
-    private updatePriorityFee;
-    private encodeNumberToArrayLE;
     checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
     getBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
     /**

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

@@ -11,6 +11,7 @@ const bs58_1 = require("bs58");
 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 = 600_000;
 class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
@@ -20,7 +21,7 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
         super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
         this.httpClient = httpClient;
         this.public = this.createPublicClient(rpcList);
-        this.gasService = new solana_gas_service_1.SolanaGasService(httpClient, this.public, solanaConfig);
+        this.gasService = new solana_gas_service_1.SolanaGasService(httpClient, this.public, logger, solanaConfig);
     }
     createPublicClient(rpcList) {
         if (!rpcList?.[0]) {
@@ -49,54 +50,14 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
             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)] }
-            // });
-            if (config.estimateConsumedUnits) {
-                const txWithBlockHash = Buffer.from(tx.serialize()).toString('base64');
-                const [computedUnitsPrice, computedUnitsLimit] = await Promise.all([
-                    this.gasService.getConsumedUnitsPrice(txWithBlockHash),
-                    this.gasService.getConsumedUnitsLimit(txWithBlockHash)
-                ]);
-                this.updatePriorityFee(tx, computedUnitsPrice.toNumber(), computedUnitsLimit.toNumber());
-            }
             const simulation = this.public.simulateTransaction(tx, { replaceRecentBlockhash: true });
-            const resp = await Promise.race([
-                simulation,
-                new Promise((_, reject) => setTimeout(() => reject('Timeout'), timeout))
-            ]);
+            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) {
             throw err;
         }
     }
-    updatePriorityFee(tx, computeUnitPrice, computeUnitLimit) {
-        const computeBudgetOfset = 1;
-        const computeUnitPriceData = tx.message.compiledInstructions[1].data;
-        const encodedPrice = this.encodeNumberToArrayLE(computeUnitPrice, 8);
-        for (let i = 0; i < encodedPrice.length; i++) {
-            computeUnitPriceData[i + computeBudgetOfset] = encodedPrice[i];
-        }
-        if (computeUnitLimit) {
-            const computeUnitLimitData = tx.message.compiledInstructions[0].data;
-            const encodedLimit = this.encodeNumberToArrayLE(computeUnitLimit, 4);
-            for (let i = 0; i < encodedLimit.length; i++) {
-                computeUnitLimitData[i + computeBudgetOfset] = encodedLimit[i];
-            }
-        }
-    }
-    encodeNumberToArrayLE(num, arraySize) {
-        const result = new Uint8Array(arraySize);
-        for (let i = 0; i < arraySize; i++) {
-            result[i] = Number(num & 0xff);
-            num >>= 8;
-        }
-        return result;
-    }
     async checkEnoughBalance(token, walletAddress) {
         const balance = await this.getBalance(walletAddress, token.address);
         return balance.gte(token.tokenAmount);

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

@@ -1,13 +1,14 @@
-import { HttpClient } from '@cryptorubic/core';
+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;
-    constructor(httpClient: HttpClient, connection: Connection, solanaConfig: SolanaAdapterConfig);
+    constructor(httpClient: HttpClient, connection: Connection, logger: ICustomLogger | undefined, solanaConfig: SolanaAdapterConfig);
     /**
      * @returns wei ComputedUnitsLimit - like gasLimit in evm
      */

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

@@ -1,24 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaGasService = void 0;
+const web3_js_1 = require("@solana/web3.js");
 const utils_1 = require("ethers/lib/utils");
 const utility_funcs_1 = require("./utility-funcs");
 const bignumber_js_1 = require("bignumber.js");
+const timeout_1 = require("../timeout");
+const DEFAULT_CU_LIMIT = 200_000; // lamports
+const DEFAULT_CU_PRICE = 1_000_000; // micro-lamports
 class SolanaGasService {
     httpClient;
     connection;
+    logger;
     HELIUS_API_URL = 'https://mainnet.helius-rpc.com';
     HELIUS_API_KEY;
-    constructor(httpClient, connection, solanaConfig) {
+    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) {
-        const DEFAULT_CU_LIMIT = 600_000;
         try {
             const tx = (0, utility_funcs_1.convertB64DataToTx)(txData);
             const resp = await this.connection.simulateTransaction(tx, {
@@ -63,10 +68,11 @@ class SolanaGasService {
                     }
                 ]
             });
+            this.logger?.customLog('HELIUS PRIORITY_FEE SUCCESS', { priorityFeeEstimate: resp.result.priorityFeeEstimate });
             return new bignumber_js_1.default(resp.result.priorityFeeEstimate);
         }
         catch (err) {
-            console.error('[SolanaGasService_getConsumedUnitsPrice] err ==> ', err);
+            this.logger?.customLog('HELIUS PRIORITY_FEE ERROR', err);
             return new bignumber_js_1.default(0);
         }
     }
@@ -74,14 +80,39 @@ class SolanaGasService {
      * @returns consumedUnitsPrice in micro-lamports(lamport * 10^-6)
      */
     async calculateCUPriceSolWeb3() {
-        const BASE_FEE = 5_000;
-        const resp = await this.connection.getRecentPrioritizationFees();
-        const avgCUPrice = resp
-            .reduce((acc, tx) => acc.plus(tx.prioritizationFee), new bignumber_js_1.default(0))
-            .div(resp.length)
-            .dp(0, bignumber_js_1.default.ROUND_CEIL);
-        const cuPrice = new bignumber_js_1.default(Math.max(BASE_FEE, avgCUPrice.toNumber()));
-        return cuPrice;
+        const estimateCULimitForTx = async (tx, idx) => {
+            if (!tx || !tx.message)
+                return { success: false, cuLimit: new bignumber_js_1.default(0), idx };
+            const transaction = web3_js_1.VersionedTransaction.deserialize(Buffer.from(tx.serialize()));
+            const simulationResp = await (0, timeout_1.withTimeout)(this.connection.simulateTransaction(transaction, { replaceRecentBlockhash: true }), 3_000, '[SolanaGasService_calculateCUPriceSolWeb3] Timeout');
+            if (typeof simulationResp !== 'object' ||
+                !simulationResp.context ||
+                !simulationResp.value ||
+                !simulationResp.value.unitsConsumed ||
+                simulationResp.value.err) {
+                return { success: false, cuLimit: new bignumber_js_1.default(0), idx };
+            }
+            return { success: true, cuLimit: new bignumber_js_1.default(simulationResp.value.unitsConsumed), idx };
+        };
+        const recentFees = await this.connection.getRecentPrioritizationFees();
+        const lastTenTxFees = recentFees.slice(recentFees.length - 10);
+        const lastBlocksSlots = await this.connection.getBlocks(lastTenTxFees[0].slot);
+        const lastBlocksSigs = await Promise.all(lastBlocksSlots.map((slot) => this.connection.getBlockSignatures(slot, 'confirmed')));
+        const flattenSigs = lastBlocksSigs.flatMap((b) => b.signatures);
+        const lastTxs = await this.connection.getTransactions(flattenSigs, { commitment: 'confirmed', maxSupportedTransactionVersion: 0 });
+        const serializedTxs = lastTxs
+            .filter(Boolean)
+            .map((tx) => web3_js_1.VersionedTransaction.deserialize(Buffer.from(tx.transaction.message.serialize())));
+        const lastCuLimits = await Promise.all(serializedTxs.map((tx, idx) => estimateCULimitForTx(tx, idx)));
+        const successCuLimits = lastCuLimits.filter((obj) => obj.success);
+        const avgCuPrice = successCuLimits.reduce((acc, cuLimitInfo) => {
+            const cuPrice = new bignumber_js_1.default(lastTenTxFees[cuLimitInfo.idx].prioritizationFee)
+                .multipliedBy(1_000_000)
+                .div(cuLimitInfo.cuLimit);
+            return cuPrice.gt(acc) ? cuPrice : acc;
+        }, new bignumber_js_1.default(0));
+        this.logger?.customLog('SOLANA_WEB3 PRIORITY_FEE SUCCESS', { priorityFeeEstimate: avgCuPrice, lastCuLimits });
+        return avgCuPrice;
     }
 }
 exports.SolanaGasService = SolanaGasService;

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