@quicknode/sdk 2.6.0 → 3.0.0-alpha.5

package/esm/solana/index.d.ts

@@ -1,76 +0,0 @@
-import * as _solana_web3_js from '@solana/web3.js';
-import { Transaction, PublicKey, Keypair, SendOptions, Connection } from '@solana/web3.js';
-
-type PercentileRangeUnion = '0' | '5' | '10' | '15' | '20' | '25' | '30' | '35' | '40' | '45' | '50' | '55' | '60' | '65' | '70' | '75' | '80' | '85' | '90' | '95' | '100';
-type PriorityFeeLevels = 'low' | 'medium' | 'high' | 'extreme' | 'recommended';
-interface PriorityFeeRequestPayload {
-    method: string;
-    params: {
-        last_n_blocks?: number;
-        account?: string;
-    };
-    id: number;
-    jsonrpc: string;
-}
-interface PriorityFeeEstimates {
-    extreme: number;
-    high: number;
-    low: number;
-    medium: number;
-    percentiles: {
-        [key in PercentileRangeUnion]: number;
-    };
-}
-interface PriorityFeeResponseData {
-    jsonrpc: string;
-    result: {
-        context: {
-            slot: number;
-        };
-        per_compute_unit: PriorityFeeEstimates;
-        per_transaction: PriorityFeeEstimates;
-        recommended: number;
-    };
-    id: number;
-}
-interface EstimatePriorityFeesParams {
-    last_n_blocks?: number;
-    account?: string;
-    api_version?: number;
-}
-interface SolanaClientArgs {
-    endpointUrl: string;
-}
-interface SmartTransactionBaseArgs {
-    transaction: Transaction;
-    feeLevel?: PriorityFeeLevels;
-}
-interface PrepareSmartTransactionArgs extends SmartTransactionBaseArgs {
-    payerPublicKey: PublicKey;
-}
-interface SendSmartTransactionArgs extends SmartTransactionBaseArgs {
-    keyPair: Keypair;
-    sendTransactionOptions?: SendOptions;
-}
-
-declare class Solana {
-    readonly endpointUrl: string;
-    readonly connection: Connection;
-    constructor({ endpointUrl }: SolanaClientArgs);
-    /**
-     * Sends a transaction with a dynamically generated priority fee based on the current network conditions and compute units needed by the transaction.
-     */
-    sendSmartTransaction(args: SendSmartTransactionArgs): Promise<string>;
-    /**
-     * Prepares a transaction to be sent with a dynamically generated priority fee based
-     * on the current network conditions. It adds a `setComputeUnitPrice` instruction to the transaction
-     * and simulates the transaction to estimate the number of compute units it will consume.
-     * The returned transaction still needs to be signed and sent to the network.
-     */
-    prepareSmartTransaction(args: PrepareSmartTransactionArgs): Promise<_solana_web3_js.Transaction>;
-    fetchEstimatePriorityFees(args?: EstimatePriorityFeesParams): Promise<PriorityFeeResponseData>;
-    private createDynamicPriorityFeeInstruction;
-    private getSimulationUnits;
-}
-
-export { EstimatePriorityFeesParams, PrepareSmartTransactionArgs, PriorityFeeEstimates, PriorityFeeLevels, PriorityFeeRequestPayload, PriorityFeeResponseData, SendSmartTransactionArgs, SmartTransactionBaseArgs, SolanaClientArgs, Solana as default };

package/esm/solana/index.js

@@ -1,2 +0,0 @@
-import { Solana } from './solana.js';
-export { Solana as default } from './solana.js';

package/esm/solana/solana.js

@@ -1,111 +0,0 @@
-import { Connection, ComputeBudgetProgram, VersionedTransaction, TransactionMessage, PublicKey } from '@solana/web3.js';
-import 'cross-fetch';
-import { getClientHeaders } from '../lib/helpers/getClientHeaders.js';
-
-// eslint-disable-next-line @nx/enforce-module-boundaries
-class Solana {
-    constructor({ endpointUrl }) {
-        const clientHeaders = getClientHeaders();
-        this.endpointUrl = endpointUrl;
-        this.connection = new Connection(endpointUrl, {
-            httpHeaders: clientHeaders,
-        });
-    }
-    /**
-     * Sends a transaction with a dynamically generated priority fee based on the current network conditions and compute units needed by the transaction.
-     */
-    async sendSmartTransaction(args) {
-        const { transaction, keyPair, feeLevel = 'medium', sendTransactionOptions = {}, } = args;
-        const smartTransaction = await this.prepareSmartTransaction({
-            transaction,
-            payerPublicKey: keyPair.publicKey,
-            feeLevel,
-        });
-        smartTransaction.sign(keyPair);
-        const hash = await this.connection.sendRawTransaction(transaction.serialize(), { skipPreflight: true, ...sendTransactionOptions });
-        return hash;
-    }
-    /**
-     * Prepares a transaction to be sent with a dynamically generated priority fee based
-     * on the current network conditions. It adds a `setComputeUnitPrice` instruction to the transaction
-     * and simulates the transaction to estimate the number of compute units it will consume.
-     * The returned transaction still needs to be signed and sent to the network.
-     */
-    async prepareSmartTransaction(args) {
-        const { transaction, payerPublicKey, feeLevel = 'medium' } = args;
-        // Send simulation with placeholders so the value calculated is accurate
-        // placeholders kept low to avoid InsufficientFundsForFee error with the high cu budget limit
-        const simulationInstructions = [
-            ComputeBudgetProgram.setComputeUnitPrice({
-                microLamports: 1,
-            }),
-            ComputeBudgetProgram.setComputeUnitLimit({ units: 1_400_000 }),
-            ...transaction.instructions,
-        ];
-        // eslint-disable-next-line prefer-const
-        let [units, computeUnitPriceInstruction, recentBlockhash] = await Promise.all([
-            this.getSimulationUnits(this.connection, simulationInstructions, payerPublicKey),
-            this.createDynamicPriorityFeeInstruction(feeLevel),
-            this.connection.getLatestBlockhash(),
-        ]);
-        transaction.add(computeUnitPriceInstruction);
-        if (units) {
-            units = Math.ceil(units * 1.05); // margin of error
-            transaction.add(ComputeBudgetProgram.setComputeUnitLimit({ units }));
-        }
-        transaction.recentBlockhash = recentBlockhash.blockhash;
-        return transaction;
-    }
-    // Get the priority fee averages based on fee data from the latest blocks
-    async fetchEstimatePriorityFees(args = {}) {
-        const payload = {
-            method: 'qn_estimatePriorityFees',
-            params: { api_version: 2, ...args },
-            id: 1,
-            jsonrpc: '2.0',
-        };
-        const response = await fetch(this.endpointUrl, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(payload),
-        });
-        if (!response.ok) {
-            if (response.status === 404) {
-                throw new Error(`The RPC method qn_estimatePriorityFees was not found on your endpoint! Your endpoint likely does not have the Priority Fee API add-on installed. Please visit https://marketplace.quicknode.com/add-on/solana-priority-fee to install the Priority Fee API and use this method to send your transactions with priority fees calculated with real-time data.`);
-            }
-            throw new Error('Failed to fetch priority fee estimates');
-        }
-        const data = await response.json();
-        return data;
-    }
-    async createDynamicPriorityFeeInstruction(feeType = 'medium') {
-        const { result } = await this.fetchEstimatePriorityFees({});
-        const priorityFee = feeType === 'recommended'
-            ? result.recommended
-            : result.per_compute_unit[feeType];
-        const priorityFeeInstruction = ComputeBudgetProgram.setComputeUnitPrice({
-            microLamports: priorityFee,
-        });
-        return priorityFeeInstruction;
-    }
-    async getSimulationUnits(connection, instructions, publicKey) {
-        const testVersionedTxn = new VersionedTransaction(new TransactionMessage({
-            instructions: instructions,
-            payerKey: publicKey,
-            recentBlockhash: PublicKey.default.toString(), // just a placeholder
-        }).compileToV0Message());
-        const simulation = await connection.simulateTransaction(testVersionedTxn, {
-            replaceRecentBlockhash: true,
-            sigVerify: false,
-        });
-        if (simulation.value.err) {
-            console.error('Simulation error:', simulation.value.err);
-            throw new Error(`Failed to simulate transaction ${JSON.stringify(simulation.value.err)}`);
-        }
-        return simulation.value.unitsConsumed;
-    }
-}
-
-export { Solana };