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

package/lib/node/assert/assert.d.ts

@@ -0,0 +1 @@
+export declare function assert(condition: boolean, error?: string): void;

package/lib/node/assert/assert.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+function assert(condition, error) {
+    if (!condition) {
+        throw new Error(error || 'Unspecified AssertionError');
+    }
+}
+exports.assert = assert;

package/lib/node/auctionSubscriber/auctionSubscriber.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { AuctionSubscriberConfig, AuctionSubscriberEvents } from './types';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+export declare class AuctionSubscriber {
+    private driftClient;
+    private opts;
+    private resubOpts?;
+    eventEmitter: StrictEventEmitter<EventEmitter, AuctionSubscriberEvents>;
+    private subscriber;
+    constructor({ driftClient, opts, resubTimeoutMs, logResubMessages, }: AuctionSubscriberConfig);
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/node/auctionSubscriber/auctionSubscriber.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuctionSubscriber = void 0;
+const memcmp_1 = require("../memcmp");
+const events_1 = require("events");
+const webSocketProgramAccountSubscriber_1 = require("../accounts/webSocketProgramAccountSubscriber");
+class AuctionSubscriber {
+    constructor({ driftClient, opts, resubTimeoutMs, logResubMessages, }) {
+        this.driftClient = driftClient;
+        this.opts = opts || this.driftClient.opts;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.resubOpts = { resubTimeoutMs, logResubMessages };
+    }
+    async subscribe() {
+        if (!this.subscriber) {
+            this.subscriber = new webSocketProgramAccountSubscriber_1.WebSocketProgramAccountSubscriber('AuctionSubscriber', 'User', this.driftClient.program, this.driftClient.program.account.user.coder.accounts.decode.bind(this.driftClient.program.account.user.coder.accounts), {
+                filters: [(0, memcmp_1.getUserFilter)(), (0, memcmp_1.getUserWithAuctionFilter)()],
+                commitment: this.opts.commitment,
+            }, this.resubOpts);
+        }
+        await this.subscriber.subscribe((accountId, data, context) => {
+            this.eventEmitter.emit('onAccountUpdate', data, accountId, context.slot);
+        });
+    }
+    async unsubscribe() {
+        if (!this.subscriber) {
+            return;
+        }
+        this.subscriber.unsubscribe();
+    }
+}
+exports.AuctionSubscriber = AuctionSubscriber;

package/lib/node/auctionSubscriber/auctionSubscriberGrpc.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { AuctionSubscriberConfig, AuctionSubscriberEvents } from './types';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+export declare class AuctionSubscriberGrpc {
+    private driftClient;
+    private opts;
+    private resubOpts?;
+    private grpcConfigs?;
+    eventEmitter: StrictEventEmitter<EventEmitter, AuctionSubscriberEvents>;
+    private subscriber;
+    constructor({ driftClient, opts, grpcConfigs, resubTimeoutMs, logResubMessages, }: AuctionSubscriberConfig);
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/node/auctionSubscriber/auctionSubscriberGrpc.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuctionSubscriberGrpc = void 0;
+const memcmp_1 = require("../memcmp");
+const events_1 = require("events");
+const grpcProgramAccountSubscriber_1 = require("../accounts/grpcProgramAccountSubscriber");
+class AuctionSubscriberGrpc {
+    constructor({ driftClient, opts, grpcConfigs, resubTimeoutMs, logResubMessages, }) {
+        this.driftClient = driftClient;
+        this.opts = opts || this.driftClient.opts;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.resubOpts = { resubTimeoutMs, logResubMessages };
+        this.grpcConfigs = grpcConfigs;
+    }
+    async subscribe() {
+        if (!this.subscriber) {
+            this.subscriber = new grpcProgramAccountSubscriber_1.grpcProgramAccountSubscriber(this.grpcConfigs, 'AuctionSubscriber', 'User', this.driftClient.program, this.driftClient.program.account.user.coder.accounts.decode.bind(this.driftClient.program.account.user.coder.accounts), {
+                filters: [(0, memcmp_1.getUserFilter)(), (0, memcmp_1.getUserWithAuctionFilter)()],
+            }, this.resubOpts);
+        }
+        await this.subscriber.subscribe((accountId, data, context) => {
+            this.eventEmitter.emit('onAccountUpdate', data, accountId, context.slot);
+        });
+    }
+    async unsubscribe() {
+        if (!this.subscriber) {
+            return;
+        }
+        this.subscriber.unsubscribe();
+    }
+}
+exports.AuctionSubscriberGrpc = AuctionSubscriberGrpc;

package/lib/node/auctionSubscriber/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './auctionSubscriber';
+export * from './auctionSubscriberGrpc';

package/lib/node/auctionSubscriber/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./auctionSubscriber"), exports);
+__exportStar(require("./auctionSubscriberGrpc"), exports);

package/lib/node/auctionSubscriber/types.d.ts

@@ -0,0 +1,14 @@
+import { GrpcConfigs } from '../accounts/types';
+import { DriftClient } from '../driftClient';
+import { UserAccount } from '../types';
+import { ConfirmOptions, PublicKey } from '@solana/web3.js';
+export type AuctionSubscriberConfig = {
+    driftClient: DriftClient;
+    opts?: ConfirmOptions;
+    resubTimeoutMs?: number;
+    logResubMessages?: boolean;
+    grpcConfigs?: GrpcConfigs;
+};
+export interface AuctionSubscriberEvents {
+    onAccountUpdate: (account: UserAccount, pubkey: PublicKey, slot: number) => void;
+}

package/lib/node/auctionSubscriber/types.js

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

package/lib/node/bankrun/bankrunConnection.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="bn.js" />
+import { AccountInfo, Keypair, PublicKey, Transaction, RpcResponseAndContext, Commitment, TransactionSignature, SignatureStatusConfig, SignatureStatus, GetVersionedTransactionConfig, GetTransactionConfig, VersionedTransaction, SimulateTransactionConfig, SimulatedTransactionResponse, TransactionError, SignatureResultCallback, ClientSubscriptionId, Connection as SolanaConnection, Blockhash, LogsFilter, LogsCallback, AccountChangeCallback } from '@solana/web3.js';
+import { ProgramTestContext, BanksClient } from 'solana-bankrun';
+import { BankrunProvider } from 'anchor-bankrun';
+import { BN, Wallet } from '@coral-xyz/anchor';
+import { Account } from '@solana/spl-token';
+export type Connection = SolanaConnection | BankrunConnection;
+type BankrunTransactionMetaNormalized = {
+    logMessages: string[];
+    err: TransactionError;
+};
+type BankrunTransactionRespose = {
+    slot: number;
+    meta: BankrunTransactionMetaNormalized;
+};
+export declare class BankrunContextWrapper {
+    readonly connection: BankrunConnection;
+    readonly context: ProgramTestContext;
+    readonly provider: BankrunProvider;
+    readonly commitment: Commitment;
+    constructor(context: ProgramTestContext, verifySignatures?: boolean);
+    sendTransaction(tx: Transaction | VersionedTransaction, additionalSigners?: Keypair[]): Promise<TransactionSignature>;
+    getMinimumBalanceForRentExemption(_: number): Promise<number>;
+    fundKeypair(keypair: Keypair | Wallet, lamports: number | bigint): Promise<TransactionSignature>;
+    getLatestBlockhash(): Promise<Blockhash>;
+    printTxLogs(signature: string): void;
+    moveTimeForward(increment: number): Promise<void>;
+    setTimestamp(unix_timestamp: number): Promise<void>;
+}
+export declare class BankrunConnection {
+    private readonly _banksClient;
+    private readonly context;
+    private transactionToMeta;
+    private clock;
+    private nextClientSubscriptionId;
+    private onLogCallbacks;
+    private onAccountChangeCallbacks;
+    private verifySignatures;
+    constructor(banksClient: BanksClient, context: ProgramTestContext, verifySignatures?: boolean);
+    getSlot(): Promise<bigint>;
+    toConnection(): SolanaConnection;
+    getTokenAccount(publicKey: PublicKey): Promise<Account>;
+    getMultipleAccountsInfo(publicKeys: PublicKey[], _commitmentOrConfig?: Commitment): Promise<AccountInfo<Buffer>[]>;
+    getAccountInfo(publicKey: PublicKey): Promise<null | AccountInfo<Buffer>>;
+    getAccountInfoAndContext(publicKey: PublicKey, _commitment?: Commitment): Promise<RpcResponseAndContext<null | AccountInfo<Buffer>>>;
+    sendRawTransaction(rawTransaction: Buffer | Uint8Array | Array<number>, _options?: any): Promise<TransactionSignature>;
+    sendTransaction(tx: Transaction | VersionedTransaction): Promise<TransactionSignature>;
+    private updateSlotAndClock;
+    getTime(): number;
+    getParsedAccountInfo(publicKey: PublicKey): Promise<RpcResponseAndContext<AccountInfo<Buffer>>>;
+    getLatestBlockhash(commitment?: Commitment): Promise<Readonly<{
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }>>;
+    getSignatureStatus(signature: string, _config?: SignatureStatusConfig): Promise<RpcResponseAndContext<null | SignatureStatus>>;
+    /**
+     * There's really no direct equivalent to getTransaction exposed by SolanaProgramTest, so we do the best that we can here - it's a little hacky.
+     */
+    getTransaction(signature: string, _rawConfig?: GetTransactionConfig | GetVersionedTransactionConfig): Promise<BankrunTransactionRespose | null>;
+    findComputeUnitConsumption(signature: string): bigint;
+    printTxLogs(signature: string): void;
+    simulateTransaction(transaction: Transaction | VersionedTransaction, _config?: SimulateTransactionConfig): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>;
+    onSignature(signature: string, callback: SignatureResultCallback, commitment?: Commitment): ClientSubscriptionId;
+    removeSignatureListener(_clientSubscriptionId: number): Promise<void>;
+    onLogs(filter: LogsFilter, callback: LogsCallback, _commitment?: Commitment): ClientSubscriptionId;
+    removeOnLogsListener(clientSubscriptionId: ClientSubscriptionId): Promise<void>;
+    onAccountChange(publicKey: PublicKey, callback: AccountChangeCallback, _commitment?: Commitment): ClientSubscriptionId;
+    removeAccountChangeListener(clientSubscriptionId: ClientSubscriptionId): Promise<void>;
+    getMinimumBalanceForRentExemption(_: number): Promise<number>;
+}
+export declare function asBN(value: number | bigint): BN;
+export {};

package/lib/node/bankrun/bankrunConnection.js

@@ -0,0 +1,318 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asBN = exports.BankrunConnection = exports.BankrunContextWrapper = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const solana_bankrun_1 = require("solana-bankrun");
+const anchor_bankrun_1 = require("anchor-bankrun");
+const bs58_1 = __importDefault(require("bs58"));
+const anchor_1 = require("@coral-xyz/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const utils_1 = require("../tx/utils");
+class BankrunContextWrapper {
+    constructor(context, verifySignatures = true) {
+        this.commitment = 'confirmed';
+        this.context = context;
+        this.provider = new anchor_bankrun_1.BankrunProvider(context);
+        this.connection = new BankrunConnection(this.context.banksClient, this.context, verifySignatures);
+    }
+    async sendTransaction(tx, additionalSigners) {
+        const isVersioned = (0, utils_1.isVersionedTransaction)(tx);
+        if (!additionalSigners) {
+            additionalSigners = [];
+        }
+        if (isVersioned) {
+            tx = tx;
+            tx.message.recentBlockhash = await this.getLatestBlockhash();
+            if (!additionalSigners) {
+                additionalSigners = [];
+            }
+            tx.sign([this.context.payer, ...additionalSigners]);
+        }
+        else {
+            tx = tx;
+            tx.recentBlockhash = await this.getLatestBlockhash();
+            tx.feePayer = this.context.payer.publicKey;
+            tx.sign(this.context.payer, ...additionalSigners);
+        }
+        return await this.connection.sendTransaction(tx);
+    }
+    async getMinimumBalanceForRentExemption(_) {
+        return 10 * web3_js_1.LAMPORTS_PER_SOL;
+    }
+    async fundKeypair(keypair, lamports) {
+        const ixs = [
+            web3_js_1.SystemProgram.transfer({
+                fromPubkey: this.context.payer.publicKey,
+                toPubkey: keypair.publicKey,
+                lamports,
+            }),
+        ];
+        const tx = new web3_js_1.Transaction().add(...ixs);
+        return await this.sendTransaction(tx);
+    }
+    async getLatestBlockhash() {
+        const blockhash = await this.connection.getLatestBlockhash('finalized');
+        return blockhash.blockhash;
+    }
+    printTxLogs(signature) {
+        this.connection.printTxLogs(signature);
+    }
+    async moveTimeForward(increment) {
+        const currentClock = await this.context.banksClient.getClock();
+        const newUnixTimestamp = currentClock.unixTimestamp + BigInt(increment);
+        const newClock = new solana_bankrun_1.Clock(currentClock.slot, currentClock.epochStartTimestamp, currentClock.epoch, currentClock.leaderScheduleEpoch, newUnixTimestamp);
+        await this.context.setClock(newClock);
+    }
+    async setTimestamp(unix_timestamp) {
+        const currentClock = await this.context.banksClient.getClock();
+        const newUnixTimestamp = BigInt(unix_timestamp);
+        const newClock = new solana_bankrun_1.Clock(currentClock.slot, currentClock.epochStartTimestamp, currentClock.epoch, currentClock.leaderScheduleEpoch, newUnixTimestamp);
+        await this.context.setClock(newClock);
+    }
+}
+exports.BankrunContextWrapper = BankrunContextWrapper;
+class BankrunConnection {
+    constructor(banksClient, context, verifySignatures = true) {
+        this.transactionToMeta = new Map();
+        this.nextClientSubscriptionId = 0;
+        this.onLogCallbacks = new Map();
+        this.onAccountChangeCallbacks = new Map();
+        this._banksClient = banksClient;
+        this.context = context;
+        this.verifySignatures = verifySignatures;
+    }
+    getSlot() {
+        return this._banksClient.getSlot();
+    }
+    toConnection() {
+        return this;
+    }
+    async getTokenAccount(publicKey) {
+        const info = await this.getAccountInfo(publicKey);
+        return (0, spl_token_1.unpackAccount)(publicKey, info, info.owner);
+    }
+    async getMultipleAccountsInfo(publicKeys, _commitmentOrConfig) {
+        const accountInfos = [];
+        for (const publicKey of publicKeys) {
+            const accountInfo = await this.getAccountInfo(publicKey);
+            accountInfos.push(accountInfo);
+        }
+        return accountInfos;
+    }
+    async getAccountInfo(publicKey) {
+        const parsedAccountInfo = await this.getParsedAccountInfo(publicKey);
+        return parsedAccountInfo ? parsedAccountInfo.value : null;
+    }
+    async getAccountInfoAndContext(publicKey, _commitment) {
+        return await this.getParsedAccountInfo(publicKey);
+    }
+    async sendRawTransaction(rawTransaction, 
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    _options) {
+        const tx = web3_js_1.Transaction.from(rawTransaction);
+        const signature = await this.sendTransaction(tx);
+        return signature;
+    }
+    async sendTransaction(tx) {
+        const isVersioned = (0, utils_1.isVersionedTransaction)(tx);
+        const serialized = isVersioned
+            ? tx.serialize()
+            : tx.serialize({
+                verifySignatures: this.verifySignatures,
+            });
+        // @ts-ignore
+        const internal = this._banksClient.inner;
+        const inner = isVersioned
+            ? await internal.tryProcessVersionedTransaction(serialized)
+            : await internal.tryProcessLegacyTransaction(serialized);
+        const banksTransactionMeta = new solana_bankrun_1.BanksTransactionResultWithMeta(inner);
+        if (banksTransactionMeta.result) {
+            throw new Error(banksTransactionMeta.result);
+        }
+        const signature = isVersioned
+            ? bs58_1.default.encode(tx.signatures[0])
+            : bs58_1.default.encode(tx.signatures[0].signature);
+        this.transactionToMeta.set(signature, banksTransactionMeta);
+        let finalizedCount = 0;
+        while (finalizedCount < 10) {
+            const signatureStatus = (await this.getSignatureStatus(signature)).value
+                .confirmationStatus;
+            if (signatureStatus.toString() == '"finalized"') {
+                finalizedCount += 1;
+            }
+        }
+        // update the clock slot/timestamp
+        // sometimes race condition causes failures so we retry
+        try {
+            await this.updateSlotAndClock();
+        }
+        catch (e) {
+            await this.updateSlotAndClock();
+        }
+        if (this.onLogCallbacks.size > 0) {
+            const transaction = await this.getTransaction(signature);
+            const context = { slot: transaction.slot };
+            const logs = {
+                logs: transaction.meta.logMessages,
+                err: transaction.meta.err,
+                signature,
+            };
+            for (const logCallback of this.onLogCallbacks.values()) {
+                logCallback(logs, context);
+            }
+        }
+        for (const [publicKey, callback,] of this.onAccountChangeCallbacks.values()) {
+            const accountInfo = await this.getParsedAccountInfo(publicKey);
+            callback(accountInfo.value, accountInfo.context);
+        }
+        return signature;
+    }
+    async updateSlotAndClock() {
+        const currentSlot = await this.getSlot();
+        const nextSlot = currentSlot + BigInt(1);
+        this.context.warpToSlot(nextSlot);
+        const currentClock = await this._banksClient.getClock();
+        const newClock = new solana_bankrun_1.Clock(nextSlot, currentClock.epochStartTimestamp, currentClock.epoch, currentClock.leaderScheduleEpoch, currentClock.unixTimestamp + BigInt(1));
+        this.context.setClock(newClock);
+        this.clock = newClock;
+    }
+    getTime() {
+        return Number(this.clock.unixTimestamp);
+    }
+    async getParsedAccountInfo(publicKey) {
+        const accountInfoBytes = await this._banksClient.getAccount(publicKey);
+        if (accountInfoBytes === null) {
+            return {
+                context: { slot: Number(await this._banksClient.getSlot()) },
+                value: null,
+            };
+        }
+        accountInfoBytes.data = Buffer.from(accountInfoBytes.data);
+        const accountInfoBuffer = accountInfoBytes;
+        return {
+            context: { slot: Number(await this._banksClient.getSlot()) },
+            value: accountInfoBuffer,
+        };
+    }
+    async getLatestBlockhash(commitment) {
+        const blockhashAndBlockheight = await this._banksClient.getLatestBlockhash(commitment);
+        return {
+            blockhash: blockhashAndBlockheight[0],
+            lastValidBlockHeight: Number(blockhashAndBlockheight[1]),
+        };
+    }
+    async getSignatureStatus(signature, _config) {
+        const transactionStatus = await this._banksClient.getTransactionStatus(signature);
+        if (transactionStatus === null) {
+            return {
+                context: { slot: Number(await this._banksClient.getSlot()) },
+                value: null,
+            };
+        }
+        return {
+            context: { slot: Number(await this._banksClient.getSlot()) },
+            value: {
+                slot: Number(transactionStatus.slot),
+                confirmations: Number(transactionStatus.confirmations),
+                err: transactionStatus.err,
+                confirmationStatus: transactionStatus.confirmationStatus,
+            },
+        };
+    }
+    /**
+     * There's really no direct equivalent to getTransaction exposed by SolanaProgramTest, so we do the best that we can here - it's a little hacky.
+     */
+    async getTransaction(signature, _rawConfig) {
+        const txMeta = this.transactionToMeta.get(signature);
+        if (txMeta === undefined) {
+            return null;
+        }
+        const transactionStatus = await this._banksClient.getTransactionStatus(signature);
+        const meta = {
+            logMessages: txMeta.meta.logMessages,
+            err: txMeta.result,
+        };
+        return {
+            slot: Number(transactionStatus.slot),
+            meta,
+        };
+    }
+    findComputeUnitConsumption(signature) {
+        const txMeta = this.transactionToMeta.get(signature);
+        if (txMeta === undefined) {
+            throw new Error('Transaction not found');
+        }
+        return txMeta.meta.computeUnitsConsumed;
+    }
+    printTxLogs(signature) {
+        const txMeta = this.transactionToMeta.get(signature);
+        if (txMeta === undefined) {
+            throw new Error('Transaction not found');
+        }
+        console.log(txMeta.meta.logMessages);
+    }
+    async simulateTransaction(transaction, _config) {
+        var _a, _b, _c, _d;
+        const simulationResult = await this._banksClient.simulateTransaction(transaction);
+        const returnDataProgramId = (_b = (_a = simulationResult.meta) === null || _a === void 0 ? void 0 : _a.returnData) === null || _b === void 0 ? void 0 : _b.programId.toBase58();
+        const returnDataNormalized = Buffer.from((_d = (_c = simulationResult.meta) === null || _c === void 0 ? void 0 : _c.returnData) === null || _d === void 0 ? void 0 : _d.data).toString('base64');
+        const returnData = {
+            programId: returnDataProgramId,
+            data: [returnDataNormalized, 'base64'],
+        };
+        return {
+            context: { slot: Number(await this._banksClient.getSlot()) },
+            value: {
+                err: simulationResult.result,
+                logs: simulationResult.meta.logMessages,
+                accounts: undefined,
+                unitsConsumed: Number(simulationResult.meta.computeUnitsConsumed),
+                returnData,
+            },
+        };
+    }
+    onSignature(signature, callback, commitment) {
+        const txMeta = this.transactionToMeta.get(signature);
+        this._banksClient.getSlot(commitment).then((slot) => {
+            if (txMeta) {
+                callback({ err: txMeta.result }, { slot: Number(slot) });
+            }
+        });
+        return 0;
+    }
+    async removeSignatureListener(_clientSubscriptionId) {
+        // Nothing actually has to happen here! Pretty cool, huh?
+        // This function signature only exists to match the web3js interface
+    }
+    onLogs(filter, callback, _commitment) {
+        const subscriptId = this.nextClientSubscriptionId;
+        this.onLogCallbacks.set(subscriptId, callback);
+        this.nextClientSubscriptionId += 1;
+        return subscriptId;
+    }
+    async removeOnLogsListener(clientSubscriptionId) {
+        this.onLogCallbacks.delete(clientSubscriptionId);
+    }
+    onAccountChange(publicKey, callback, 
+    // @ts-ignore
+    _commitment) {
+        const subscriptId = this.nextClientSubscriptionId;
+        this.onAccountChangeCallbacks.set(subscriptId, [publicKey, callback]);
+        this.nextClientSubscriptionId += 1;
+        return subscriptId;
+    }
+    async removeAccountChangeListener(clientSubscriptionId) {
+        this.onAccountChangeCallbacks.delete(clientSubscriptionId);
+    }
+    async getMinimumBalanceForRentExemption(_) {
+        return 10 * web3_js_1.LAMPORTS_PER_SOL;
+    }
+}
+exports.BankrunConnection = BankrunConnection;
+function asBN(value) {
+    return new anchor_1.BN(Number(value));
+}
+exports.asBN = asBN;

package/lib/node/blockhashSubscriber/BlockhashSubscriber.d.ts

@@ -0,0 +1,27 @@
+import { BlockhashWithExpiryBlockHeight, Context } from '@solana/web3.js';
+import { BlockhashSubscriberConfig } from './types';
+export declare class BlockhashSubscriber {
+    private connection;
+    private isSubscribed;
+    private latestBlockHeight;
+    private latestBlockHeightContext;
+    private blockhashes;
+    private updateBlockhashIntervalId;
+    private commitment;
+    private updateIntervalMs;
+    constructor(config: BlockhashSubscriberConfig);
+    getBlockhashCacheSize(): number;
+    getLatestBlockHeight(): number;
+    getLatestBlockHeightContext(): Context | undefined;
+    /**
+     * Returns the latest cached blockhash, based on an offset from the latest obtained
+     * @param offset Offset to use, defaulting to 0
+     * @param offsetType If 'seconds', it will use calculate the actual element offset based on the update interval; otherwise it will return a fixed index
+     * @returns Cached blockhash at the given offset, or undefined
+     */
+    getLatestBlockhash(offset?: number, offsetType?: 'index' | 'seconds'): BlockhashWithExpiryBlockHeight | undefined;
+    pruneBlockhashes(): void;
+    updateBlockhash(): Promise<void>;
+    subscribe(): Promise<void>;
+    unsubscribe(): void;
+}

package/lib/node/blockhashSubscriber/BlockhashSubscriber.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockhashSubscriber = void 0;
+const web3_js_1 = require("@solana/web3.js");
+class BlockhashSubscriber {
+    constructor(config) {
+        var _a, _b;
+        this.isSubscribed = false;
+        this.blockhashes = [];
+        if (!config.connection && !config.rpcUrl) {
+            throw new Error('BlockhashSubscriber requires one of connection or rpcUrl must be provided');
+        }
+        this.connection = config.connection || new web3_js_1.Connection(config.rpcUrl);
+        this.commitment = (_a = config.commitment) !== null && _a !== void 0 ? _a : 'confirmed';
+        this.updateIntervalMs = (_b = config.updateIntervalMs) !== null && _b !== void 0 ? _b : 1000;
+    }
+    getBlockhashCacheSize() {
+        return this.blockhashes.length;
+    }
+    getLatestBlockHeight() {
+        return this.latestBlockHeight;
+    }
+    getLatestBlockHeightContext() {
+        return this.latestBlockHeightContext;
+    }
+    /**
+     * Returns the latest cached blockhash, based on an offset from the latest obtained
+     * @param offset Offset to use, defaulting to 0
+     * @param offsetType If 'seconds', it will use calculate the actual element offset based on the update interval; otherwise it will return a fixed index
+     * @returns Cached blockhash at the given offset, or undefined
+     */
+    getLatestBlockhash(offset = 0, offsetType = 'index') {
+        if (this.blockhashes.length === 0) {
+            return undefined;
+        }
+        const elementOffset = offsetType == 'seconds'
+            ? Math.floor((offset * 1000) / this.updateIntervalMs)
+            : offset;
+        const clampedOffset = Math.max(0, Math.min(this.blockhashes.length - 1, elementOffset));
+        return this.blockhashes[this.blockhashes.length - 1 - clampedOffset];
+    }
+    pruneBlockhashes() {
+        if (this.latestBlockHeight) {
+            this.blockhashes = this.blockhashes.filter((blockhash) => blockhash.lastValidBlockHeight > this.latestBlockHeight);
+        }
+    }
+    async updateBlockhash() {
+        try {
+            const [resp, lastConfirmedBlockHeight] = await Promise.all([
+                this.connection.getLatestBlockhashAndContext({
+                    commitment: this.commitment,
+                }),
+                this.connection.getBlockHeight({ commitment: this.commitment }),
+            ]);
+            this.latestBlockHeight = lastConfirmedBlockHeight;
+            this.latestBlockHeightContext = resp.context;
+            // avoid caching duplicate blockhashes
+            if (this.blockhashes.length > 0) {
+                if (resp.value.blockhash ===
+                    this.blockhashes[this.blockhashes.length - 1].blockhash) {
+                    return;
+                }
+            }
+            this.blockhashes.push(resp.value);
+        }
+        catch (e) {
+            console.error('Error updating blockhash:\n', e);
+        }
+        finally {
+            this.pruneBlockhashes();
+        }
+    }
+    async subscribe() {
+        if (this.isSubscribed) {
+            return;
+        }
+        this.isSubscribed = true;
+        await this.updateBlockhash();
+        this.updateBlockhashIntervalId = setInterval(this.updateBlockhash.bind(this), this.updateIntervalMs);
+    }
+    unsubscribe() {
+        if (this.updateBlockhashIntervalId) {
+            clearInterval(this.updateBlockhashIntervalId);
+            this.updateBlockhashIntervalId = undefined;
+        }
+        this.isSubscribed = false;
+    }
+}
+exports.BlockhashSubscriber = BlockhashSubscriber;

package/lib/node/blockhashSubscriber/index.d.ts

@@ -0,0 +1 @@
+export * from './BlockhashSubscriber';