@drift-labs/sdk 2.97.0-beta.21 → 2.97.0-beta.23

package/lib/node/userMap/userStatsMap.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserStatsMap = void 0;
+const __1 = require("..");
+const web3_js_1 = require("@solana/web3.js");
+class UserStatsMap {
+    /**
+     * Creates a new UserStatsMap instance.
+     *
+     * @param {DriftClient} driftClient - The DriftClient instance.
+     * @param {BulkAccountLoader} [bulkAccountLoader] - If not provided, a new BulkAccountLoader with polling disabled will be created.
+     */
+    constructor(driftClient, bulkAccountLoader) {
+        /**
+         * map from authority pubkey to UserStats
+         */
+        this.userStatsMap = new Map();
+        this.driftClient = driftClient;
+        if (!bulkAccountLoader) {
+            bulkAccountLoader = new __1.BulkAccountLoader(driftClient.connection, driftClient.opts.commitment, 0);
+        }
+        this.bulkAccountLoader = bulkAccountLoader;
+    }
+    async subscribe(authorities) {
+        if (this.size() > 0) {
+            return;
+        }
+        await this.driftClient.subscribe();
+        await this.sync(authorities);
+    }
+    /**
+     *
+     * @param authority that owns the UserStatsAccount
+     * @param userStatsAccount optional UserStatsAccount to subscribe to, if undefined will be fetched later
+     * @param skipFetch if true, will not immediately fetch the UserStatsAccount
+     */
+    async addUserStat(authority, userStatsAccount, skipFetch) {
+        const userStat = new __1.UserStats({
+            driftClient: this.driftClient,
+            userStatsAccountPublicKey: (0, __1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, authority),
+            accountSubscription: {
+                type: 'polling',
+                accountLoader: this.bulkAccountLoader,
+            },
+        });
+        if (skipFetch) {
+            await userStat.accountSubscriber.addToAccountLoader();
+        }
+        else {
+            await userStat.subscribe(userStatsAccount);
+        }
+        this.userStatsMap.set(authority.toString(), userStat);
+    }
+    async updateWithOrderRecord(record, userMap) {
+        const user = await userMap.mustGet(record.user.toString());
+        if (!this.has(user.getUserAccount().authority.toString())) {
+            await this.addUserStat(user.getUserAccount().authority, undefined, false);
+        }
+    }
+    async updateWithEventRecord(record, userMap) {
+        if (record.eventType === 'DepositRecord') {
+            const depositRecord = record;
+            await this.mustGet(depositRecord.userAuthority.toString());
+        }
+        else if (record.eventType === 'FundingPaymentRecord') {
+            const fundingPaymentRecord = record;
+            await this.mustGet(fundingPaymentRecord.userAuthority.toString());
+        }
+        else if (record.eventType === 'LiquidationRecord') {
+            if (!userMap) {
+                return;
+            }
+            const liqRecord = record;
+            const user = await userMap.mustGet(liqRecord.user.toString());
+            await this.mustGet(user.getUserAccount().authority.toString());
+            const liquidatorUser = await userMap.mustGet(liqRecord.liquidator.toString());
+            await this.mustGet(liquidatorUser.getUserAccount().authority.toString());
+        }
+        else if (record.eventType === 'OrderRecord') {
+            if (!userMap) {
+                return;
+            }
+            const orderRecord = record;
+            await userMap.updateWithOrderRecord(orderRecord);
+        }
+        else if (record.eventType === 'OrderActionRecord') {
+            if (!userMap) {
+                return;
+            }
+            const actionRecord = record;
+            if (actionRecord.taker) {
+                const taker = await userMap.mustGet(actionRecord.taker.toString());
+                await this.mustGet(taker.getUserAccount().authority.toString());
+            }
+            if (actionRecord.maker) {
+                const maker = await userMap.mustGet(actionRecord.maker.toString());
+                await this.mustGet(maker.getUserAccount().authority.toString());
+            }
+        }
+        else if (record.eventType === 'SettlePnlRecord') {
+            if (!userMap) {
+                return;
+            }
+            const settlePnlRecord = record;
+            const user = await userMap.mustGet(settlePnlRecord.user.toString());
+            await this.mustGet(user.getUserAccount().authority.toString());
+        }
+        else if (record.eventType === 'NewUserRecord') {
+            const newUserRecord = record;
+            await this.mustGet(newUserRecord.userAuthority.toString());
+        }
+        else if (record.eventType === 'LPRecord') {
+            if (!userMap) {
+                return;
+            }
+            const lpRecord = record;
+            const user = await userMap.mustGet(lpRecord.user.toString());
+            await this.mustGet(user.getUserAccount().authority.toString());
+        }
+        else if (record.eventType === 'InsuranceFundStakeRecord') {
+            const ifStakeRecord = record;
+            await this.mustGet(ifStakeRecord.userAuthority.toString());
+        }
+    }
+    has(authorityPublicKey) {
+        return this.userStatsMap.has(authorityPublicKey);
+    }
+    get(authorityPublicKey) {
+        return this.userStatsMap.get(authorityPublicKey);
+    }
+    /**
+     * Enforce that a UserStats will exist for the given authorityPublicKey,
+     * reading one from the blockchain if necessary.
+     * @param authorityPublicKey
+     * @returns
+     */
+    async mustGet(authorityPublicKey) {
+        if (!this.has(authorityPublicKey)) {
+            await this.addUserStat(new web3_js_1.PublicKey(authorityPublicKey), undefined, false);
+        }
+        return this.get(authorityPublicKey);
+    }
+    values() {
+        return this.userStatsMap.values();
+    }
+    size() {
+        return this.userStatsMap.size;
+    }
+    /**
+     * Sync the UserStatsMap
+     * @param authorities list of authorities to derive UserStatsAccount public keys from.
+     * You may want to get this list from UserMap in order to filter out idle users
+     */
+    async sync(authorities) {
+        await Promise.all(authorities.map((authority) => this.addUserStat(authority, undefined, true)));
+        await this.bulkAccountLoader.load();
+    }
+    async unsubscribe() {
+        for (const [key, userStats] of this.userStatsMap.entries()) {
+            await userStats.unsubscribe();
+            this.userStatsMap.delete(key);
+        }
+    }
+}
+exports.UserStatsMap = UserStatsMap;

package/lib/node/userName.d.ts

@@ -0,0 +1,5 @@
+export declare const MAX_NAME_LENGTH = 32;
+export declare const DEFAULT_USER_NAME = "Main Account";
+export declare const DEFAULT_MARKET_NAME = "Default Market Name";
+export declare function encodeName(name: string): number[];
+export declare function decodeName(bytes: number[]): string;

package/lib/node/userName.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeName = exports.encodeName = exports.DEFAULT_MARKET_NAME = exports.DEFAULT_USER_NAME = exports.MAX_NAME_LENGTH = void 0;
+exports.MAX_NAME_LENGTH = 32;
+exports.DEFAULT_USER_NAME = 'Main Account';
+exports.DEFAULT_MARKET_NAME = 'Default Market Name';
+function encodeName(name) {
+    if (name.length > exports.MAX_NAME_LENGTH) {
+        throw Error(`Name (${name}) longer than 32 characters`);
+    }
+    const buffer = Buffer.alloc(32);
+    buffer.fill(name);
+    buffer.fill(' ', name.length);
+    return Array(...buffer);
+}
+exports.encodeName = encodeName;
+function decodeName(bytes) {
+    const buffer = Buffer.from(bytes);
+    return buffer.toString('utf8').trim();
+}
+exports.decodeName = decodeName;

package/lib/node/userStats.d.ts

@@ -0,0 +1,19 @@
+import { DriftClient } from './driftClient';
+import { PublicKey } from '@solana/web3.js';
+import { DataAndSlot, UserStatsAccountSubscriber } from './accounts/types';
+import { UserStatsConfig } from './userStatsConfig';
+import { ReferrerInfo, UserStatsAccount } from './types';
+export declare class UserStats {
+    driftClient: DriftClient;
+    userStatsAccountPublicKey: PublicKey;
+    accountSubscriber: UserStatsAccountSubscriber;
+    isSubscribed: boolean;
+    constructor(config: UserStatsConfig);
+    subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean>;
+    fetchAccounts(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    getAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+    getAccount(): UserStatsAccount;
+    getReferrerInfo(): ReferrerInfo | undefined;
+    static getOldestActionTs(account: UserStatsAccount): number;
+}

package/lib/node/userStats.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserStats = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const pollingUserStatsAccountSubscriber_1 = require("./accounts/pollingUserStatsAccountSubscriber");
+const webSocketUserStatsAccountSubsriber_1 = require("./accounts/webSocketUserStatsAccountSubsriber");
+const pda_1 = require("./addresses/pda");
+const grpcUserStatsAccountSubscriber_1 = require("./accounts/grpcUserStatsAccountSubscriber");
+class UserStats {
+    constructor(config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        this.driftClient = config.driftClient;
+        this.userStatsAccountPublicKey = config.userStatsAccountPublicKey;
+        if (((_a = config.accountSubscription) === null || _a === void 0 ? void 0 : _a.type) === 'polling') {
+            this.accountSubscriber = new pollingUserStatsAccountSubscriber_1.PollingUserStatsAccountSubscriber(config.driftClient.program, config.userStatsAccountPublicKey, config.accountSubscription.accountLoader);
+        }
+        else if (((_b = config.accountSubscription) === null || _b === void 0 ? void 0 : _b.type) === 'grpc') {
+            this.accountSubscriber = new grpcUserStatsAccountSubscriber_1.grpcUserStatsAccountSubscriber(config.accountSubscription.grpcConfigs, config.driftClient.program, config.userStatsAccountPublicKey, {
+                resubTimeoutMs: (_c = config.accountSubscription) === null || _c === void 0 ? void 0 : _c.resubTimeoutMs,
+                logResubMessages: (_d = config.accountSubscription) === null || _d === void 0 ? void 0 : _d.logResubMessages,
+            });
+        }
+        else if (((_e = config.accountSubscription) === null || _e === void 0 ? void 0 : _e.type) === 'websocket') {
+            this.accountSubscriber = new webSocketUserStatsAccountSubsriber_1.WebSocketUserStatsAccountSubscriber(config.driftClient.program, config.userStatsAccountPublicKey, {
+                resubTimeoutMs: (_f = config.accountSubscription) === null || _f === void 0 ? void 0 : _f.resubTimeoutMs,
+                logResubMessages: (_g = config.accountSubscription) === null || _g === void 0 ? void 0 : _g.logResubMessages,
+            }, config.accountSubscription.commitment);
+        }
+        else {
+            throw new Error(`Unknown user stats account subscription type: ${(_h = config.accountSubscription) === null || _h === void 0 ? void 0 : _h.type}`);
+        }
+    }
+    async subscribe(userStatsAccount) {
+        this.isSubscribed = await this.accountSubscriber.subscribe(userStatsAccount);
+        return this.isSubscribed;
+    }
+    async fetchAccounts() {
+        await this.accountSubscriber.fetch();
+    }
+    async unsubscribe() {
+        await this.accountSubscriber.unsubscribe();
+        this.isSubscribed = false;
+    }
+    getAccountAndSlot() {
+        return this.accountSubscriber.getUserStatsAccountAndSlot();
+    }
+    getAccount() {
+        return this.accountSubscriber.getUserStatsAccountAndSlot().data;
+    }
+    getReferrerInfo() {
+        if (this.getAccount().referrer.equals(web3_js_1.PublicKey.default)) {
+            return undefined;
+        }
+        else {
+            return {
+                referrer: (0, pda_1.getUserAccountPublicKeySync)(this.driftClient.program.programId, this.getAccount().referrer, 0),
+                referrerStats: (0, pda_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, this.getAccount().referrer),
+            };
+        }
+    }
+    static getOldestActionTs(account) {
+        return Math.min(account.lastFillerVolume30DTs.toNumber(), account.lastMakerVolume30DTs.toNumber(), account.lastTakerVolume30DTs.toNumber());
+    }
+}
+exports.UserStats = UserStats;

package/lib/node/userStatsConfig.d.ts

@@ -0,0 +1,25 @@
+import { DriftClient } from './driftClient';
+import { Commitment, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { GrpcConfigs } from './accounts/types';
+export type UserStatsConfig = {
+    accountSubscription?: UserStatsSubscriptionConfig;
+    driftClient: DriftClient;
+    userStatsAccountPublicKey: PublicKey;
+};
+export type UserStatsSubscriptionConfig = {
+    type: 'websocket';
+    resubTimeoutMs?: number;
+    logResubMessages?: boolean;
+    commitment?: Commitment;
+} | {
+    type: 'polling';
+    accountLoader: BulkAccountLoader;
+} | {
+    type: 'custom';
+} | {
+    type: 'grpc';
+    resubTimeoutMs?: number;
+    logResubMessages?: boolean;
+    grpcConfigs: GrpcConfigs;
+};

package/lib/node/userStatsConfig.js

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

package/lib/node/util/TransactionConfirmationManager.d.ts

@@ -0,0 +1,16 @@
+import { Connection, RpcResponseAndContext, SignatureResult, SignatureStatus, TransactionConfirmationStatus } from '@solana/web3.js';
+/**
+ * Class to await for transaction confirmations in an optimised manner. It tracks a shared list of all pending transactions and fetches them in bulk in a shared RPC request whenever they have an "overlapping" polling interval. E.g. tx1 with an interval of 200ms and tx2 with an interval of 300ms (if sent at the same time) will be fetched together at at 600ms, 1200ms, 1800ms, etc.
+ */
+export declare class TransactionConfirmationManager {
+    private connection;
+    private pendingConfirmations;
+    private intervalId;
+    constructor(connection: Connection);
+    confirmTransactionWebSocket(txSig: string, timeout?: number, desiredConfirmationStatus?: TransactionConfirmationStatus): Promise<RpcResponseAndContext<SignatureResult>>;
+    confirmTransactionPolling(txSig: string, desiredConfirmationStatus?: TransactionConfirmationStatus, timeout?: number, pollInterval?: number, searchTransactionHistory?: boolean): Promise<SignatureStatus>;
+    private startConfirmationLoop;
+    private checkPendingConfirmations;
+    private checkStatusMatchesDesiredConfirmationStatus;
+    private checkTransactionStatuses;
+}

package/lib/node/util/TransactionConfirmationManager.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionConfirmationManager = void 0;
+const config_1 = require("../config");
+const __1 = require("..");
+const txConstants_1 = require("../constants/txConstants");
+const reportTransactionError_1 = require("../tx/reportTransactionError");
+const promiseTimeout_1 = require("./promiseTimeout");
+const confirmationStatusValues = {
+    processed: 0,
+    confirmed: 1,
+    finalized: 2,
+};
+/**
+ * Class to await for transaction confirmations in an optimised manner. It tracks a shared list of all pending transactions and fetches them in bulk in a shared RPC request whenever they have an "overlapping" polling interval. E.g. tx1 with an interval of 200ms and tx2 with an interval of 300ms (if sent at the same time) will be fetched together at at 600ms, 1200ms, 1800ms, etc.
+ */
+class TransactionConfirmationManager {
+    constructor(connection) {
+        this.pendingConfirmations = new Map();
+        this.intervalId = null;
+        this.connection = connection;
+    }
+    async confirmTransactionWebSocket(txSig, timeout = 30000, desiredConfirmationStatus = config_1.DEFAULT_CONFIRMATION_OPTS.commitment) {
+        const start = Date.now();
+        const subscriptionCommitment = desiredConfirmationStatus || config_1.DEFAULT_CONFIRMATION_OPTS.commitment;
+        let response = null;
+        let subscriptionId;
+        const confirmationPromise = new Promise((resolve, reject) => {
+            try {
+                subscriptionId = this.connection.onSignature(txSig, (result, context) => {
+                    response = {
+                        context,
+                        value: result,
+                    };
+                    resolve(null);
+                }, subscriptionCommitment);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        // We do a one-shot confirmation check just in case the transaction is ALREADY confirmed when we create the websocket confirmation .. We want to run this concurrently with the onSignature subscription. If this returns true then we can return early as the transaction has already been confirmed.
+        const oneShotConfirmationPromise = this.connection.getSignatureStatuses([
+            txSig,
+        ]);
+        const resolveReference = {};
+        // This is the promise we are waiting on to resolve the overall confirmation. It will resolve the faster of a positive oneShot confirmation, or the websocket confirmation, or the timeout.
+        const overallWaitingForConfirmationPromise = new Promise((resolve) => {
+            resolveReference.resolve = resolve;
+        });
+        // Await for the one shot confirmation and resolve the waiting promise if we get a positive confirmation result
+        oneShotConfirmationPromise.then(async (oneShotResponse) => {
+            var _a, _b;
+            if (!oneShotResponse || !((_a = oneShotResponse === null || oneShotResponse === void 0 ? void 0 : oneShotResponse.value) === null || _a === void 0 ? void 0 : _a[0]))
+                return;
+            const resultValue = oneShotResponse.value[0];
+            if (resultValue.err) {
+                await (0, reportTransactionError_1.throwTransactionError)(txSig, this.connection);
+            }
+            if (this.checkStatusMatchesDesiredConfirmationStatus(resultValue, desiredConfirmationStatus)) {
+                response = {
+                    context: oneShotResponse.context,
+                    value: oneShotResponse.value[0],
+                };
+                (_b = resolveReference.resolve) === null || _b === void 0 ? void 0 : _b.call(resolveReference);
+            }
+        }, (onRejected) => {
+            throw onRejected;
+        });
+        // Await for the websocket confirmation with the configured timeout
+        (0, promiseTimeout_1.promiseTimeout)(confirmationPromise, timeout).then(() => {
+            var _a;
+            (_a = resolveReference.resolve) === null || _a === void 0 ? void 0 : _a.call(resolveReference);
+        }, (onRejected) => {
+            throw onRejected;
+        });
+        try {
+            await overallWaitingForConfirmationPromise;
+        }
+        finally {
+            if (subscriptionId !== undefined) {
+                this.connection.removeSignatureListener(subscriptionId);
+            }
+        }
+        const duration = (Date.now() - start) / 1000;
+        if (response === null) {
+            throw new __1.TxSendError(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${txSig} using the Solana Explorer or CLI tools.`, txConstants_1.NOT_CONFIRMED_ERROR_CODE);
+        }
+        return response;
+    }
+    async confirmTransactionPolling(txSig, desiredConfirmationStatus = config_1.DEFAULT_CONFIRMATION_OPTS.commitment, timeout = 30000, pollInterval = 1000, searchTransactionHistory = false) {
+        // Interval must be > 400ms and a multiple of 100ms
+        if (pollInterval < 400 || pollInterval % 100 !== 0) {
+            throw new Error('Transaction confirmation polling interval must be at least 400ms and a multiple of 100ms');
+        }
+        return new Promise((resolve, reject) => {
+            this.pendingConfirmations.set(txSig, {
+                txSig,
+                desiredConfirmationStatus,
+                timeout,
+                pollInterval,
+                searchTransactionHistory,
+                startTime: Date.now(),
+                resolve,
+                reject,
+            });
+            if (!this.intervalId) {
+                this.startConfirmationLoop();
+            }
+        });
+    }
+    startConfirmationLoop() {
+        this.intervalId = setInterval(() => this.checkPendingConfirmations(), 100);
+    }
+    async checkPendingConfirmations() {
+        const now = Date.now();
+        const transactionsToCheck = [];
+        for (const [txSig, request] of this.pendingConfirmations.entries()) {
+            if (now - request.startTime >= request.timeout) {
+                request.reject(new Error(`Transaction confirmation timeout after ${request.timeout}ms`));
+                this.pendingConfirmations.delete(txSig);
+            }
+            else if ((now - request.startTime) % request.pollInterval < 100) {
+                transactionsToCheck.push(request);
+            }
+        }
+        if (transactionsToCheck.length > 0) {
+            await this.checkTransactionStatuses(transactionsToCheck);
+        }
+        if (this.pendingConfirmations.size === 0 && this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    checkStatusMatchesDesiredConfirmationStatus(status, desiredConfirmationStatus) {
+        if (status.confirmationStatus &&
+            confirmationStatusValues[status.confirmationStatus] >=
+                confirmationStatusValues[desiredConfirmationStatus]) {
+            return true;
+        }
+        return false;
+    }
+    async checkTransactionStatuses(requests) {
+        const txSigs = requests.map((request) => request.txSig);
+        const { value: statuses } = await this.connection.getSignatureStatuses(txSigs, {
+            searchTransactionHistory: requests.some((req) => req.searchTransactionHistory),
+        });
+        if (!statuses || statuses.length !== txSigs.length) {
+            throw new Error('Failed to get signature statuses');
+        }
+        for (let i = 0; i < statuses.length; i++) {
+            const status = statuses[i];
+            const request = requests[i];
+            if (status === null) {
+                continue;
+            }
+            if (status.err) {
+                this.pendingConfirmations.delete(request.txSig);
+                request.reject(await (0, reportTransactionError_1.getTransactionErrorFromTxSig)(request.txSig, this.connection));
+                continue;
+            }
+            if (confirmationStatusValues[status.confirmationStatus] === undefined ||
+                confirmationStatusValues[request.desiredConfirmationStatus] ===
+                    undefined) {
+                throw new Error(`Invalid confirmation status when awaiting confirmation: ${status.confirmationStatus}`);
+            }
+            if (this.checkStatusMatchesDesiredConfirmationStatus(status, request.desiredConfirmationStatus)) {
+                request.resolve(status);
+                this.pendingConfirmations.delete(request.txSig);
+            }
+        }
+    }
+}
+exports.TransactionConfirmationManager = TransactionConfirmationManager;

package/lib/node/util/chainClock.d.ts

@@ -0,0 +1,17 @@
+import { Commitment } from '@solana/web3.js';
+export type ChainClockProgress = {
+    blockHeight?: number;
+    slot?: number;
+    ts?: number;
+};
+export type ChainClockUpdateProps = {
+    commitment: Commitment;
+} & ChainClockProgress;
+export type ChainClockState = Map<Commitment, ChainClockProgress>;
+export type ChainClickInitialisationProps = ChainClockUpdateProps[];
+export declare class ChainClock {
+    private _state;
+    constructor(props: ChainClickInitialisationProps);
+    update(props: ChainClockUpdateProps): void;
+    getState(commitment: Commitment): ChainClockProgress;
+}

package/lib/node/util/chainClock.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainClock = void 0;
+class ChainClock {
+    constructor(props) {
+        this._state = new Map();
+        props.forEach((prop) => {
+            this._state.set(prop.commitment, prop);
+        });
+    }
+    update(props) {
+        const state = this._state.get(props.commitment);
+        if (state) {
+            if (props.blockHeight)
+                state.blockHeight = props.blockHeight;
+            if (props.slot)
+                state.slot = props.slot;
+            if (props.ts)
+                state.ts = props.ts;
+        }
+        else {
+            this._state.set(props.commitment, props);
+        }
+    }
+    getState(commitment) {
+        return this._state.get(commitment);
+    }
+}
+exports.ChainClock = ChainClock;

package/lib/node/util/computeUnits.d.ts

@@ -0,0 +1,8 @@
+import { Connection, Finality, PublicKey, TransactionInstruction } from '@solana/web3.js';
+export declare function findComputeUnitConsumption(programId: PublicKey, connection: Connection, txSignature: string, commitment?: Finality): Promise<number[]>;
+export declare function isSetComputeUnitsIx(ix: TransactionInstruction): boolean;
+export declare function isSetComputeUnitPriceIx(ix: TransactionInstruction): boolean;
+export declare function containsComputeUnitIxs(ixs: TransactionInstruction[]): {
+    hasSetComputeUnitLimitIx: boolean;
+    hasSetComputeUnitPriceIx: boolean;
+};

package/lib/node/util/computeUnits.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsComputeUnitIxs = exports.isSetComputeUnitPriceIx = exports.isSetComputeUnitsIx = exports.findComputeUnitConsumption = void 0;
+const web3_js_1 = require("@solana/web3.js");
+async function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
+    const tx = await connection.getTransaction(txSignature, { commitment });
+    const computeUnits = [];
+    const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of ([0-9]{0,7}) compute units`);
+    tx.meta.logMessages.forEach((logMessage) => {
+        const match = logMessage.match(regex);
+        if (match && match[1]) {
+            computeUnits.push(match[1]);
+        }
+    });
+    return computeUnits;
+}
+exports.findComputeUnitConsumption = findComputeUnitConsumption;
+function isSetComputeUnitsIx(ix) {
+    // Compute budget program discriminator is first byte
+    // 2: set compute unit limit
+    // 3: set compute unit price
+    if (ix.programId.equals(web3_js_1.ComputeBudgetProgram.programId) &&
+        ix.data.at(0) === 2) {
+        return true;
+    }
+    return false;
+}
+exports.isSetComputeUnitsIx = isSetComputeUnitsIx;
+function isSetComputeUnitPriceIx(ix) {
+    // Compute budget program discriminator is first byte
+    // 2: set compute unit limit
+    // 3: set compute unit price
+    if (ix.programId.equals(web3_js_1.ComputeBudgetProgram.programId) &&
+        ix.data.at(0) === 3) {
+        return true;
+    }
+    return false;
+}
+exports.isSetComputeUnitPriceIx = isSetComputeUnitPriceIx;
+function containsComputeUnitIxs(ixs) {
+    return {
+        hasSetComputeUnitLimitIx: ixs.some(isSetComputeUnitsIx),
+        hasSetComputeUnitPriceIx: ixs.some(isSetComputeUnitPriceIx),
+    };
+}
+exports.containsComputeUnitIxs = containsComputeUnitIxs;

package/lib/node/util/promiseTimeout.d.ts

@@ -0,0 +1 @@
+export declare function promiseTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | null>;

package/lib/node/util/promiseTimeout.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTimeout = void 0;
+function promiseTimeout(promise, timeoutMs) {
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => resolve(null), timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).then((result) => {
+        clearTimeout(timeoutId);
+        return result;
+    });
+}
+exports.promiseTimeout = promiseTimeout;

package/lib/node/util/pythPullOracleUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function trimFeedId(feedId: string): string;
+export declare function getFeedIdUint8Array(feedId: string): Uint8Array;

package/lib/node/util/pythPullOracleUtils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFeedIdUint8Array = exports.trimFeedId = void 0;
+function trimFeedId(feedId) {
+    if (feedId.startsWith('0x')) {
+        return feedId.slice(2);
+    }
+    return feedId;
+}
+exports.trimFeedId = trimFeedId;
+function getFeedIdUint8Array(feedId) {
+    const trimmedFeedId = trimFeedId(feedId);
+    return Uint8Array.from(Buffer.from(trimmedFeedId, 'hex'));
+}
+exports.getFeedIdUint8Array = getFeedIdUint8Array;

package/lib/node/util/tps.d.ts

@@ -0,0 +1,2 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+export declare function estimateTps(programId: PublicKey, connection: Connection, failed: boolean): Promise<number>;

package/lib/node/util/tps.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTps = void 0;
+async function estimateTps(programId, connection, failed) {
+    let signatures = await connection.getSignaturesForAddress(programId, undefined, 'finalized');
+    if (failed) {
+        signatures = signatures.filter((signature) => signature.err);
+    }
+    const numberOfSignatures = signatures.length;
+    if (numberOfSignatures === 0) {
+        return 0;
+    }
+    return (numberOfSignatures /
+        (signatures[0].blockTime - signatures[numberOfSignatures - 1].blockTime));
+}
+exports.estimateTps = estimateTps;