@drift-labs/sdk 2.74.0-beta.2 → 2.74.0-beta.4

package/VERSION

@@ -1 +1 @@
-2.74.0-beta.2
+2.74.0-beta.4

package/lib/blockhashSubscriber/BlockhashSubscriber.d.ts

@@ -0,0 +1,21 @@
+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;
+    getLatestBlockhash(offset?: number): BlockhashWithExpiryBlockHeight | undefined;
+    pruneBlockhashes(): void;
+    updateBlockhash(): Promise<void>;
+    subscribe(): Promise<void>;
+    unsubscribe(): void;
+}

package/lib/blockhashSubscriber/BlockhashSubscriber.js

@@ -0,0 +1,73 @@
+"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;
+    }
+    getLatestBlockhash(offset) {
+        if (this.blockhashes.length === 0) {
+            return undefined;
+        }
+        const clampedOffset = Math.max(0, Math.min(this.blockhashes.length - 1, offset !== null && offset !== void 0 ? offset : 0));
+        return this.blockhashes[this.blockhashes.length - 1 - clampedOffset];
+    }
+    pruneBlockhashes() {
+        if (this.latestBlockHeight) {
+            this.blockhashes = this.blockhashes.filter((blockhash) => blockhash.lastValidBlockHeight > this.latestBlockHeight);
+        }
+    }
+    async updateBlockhash() {
+        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);
+        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/blockhashSubscriber/index.d.ts

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

package/lib/blockhashSubscriber/index.js

@@ -0,0 +1,17 @@
+"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("./BlockhashSubscriber"), exports);

package/lib/blockhashSubscriber/types.d.ts

@@ -0,0 +1,7 @@
+import { Commitment, Connection } from '@solana/web3.js';
+export type BlockhashSubscriberConfig = {
+    rpcUrl?: string;
+    connection?: Connection;
+    commitment?: Commitment;
+    updateIntervalMs?: number;
+};

package/lib/blockhashSubscriber/types.js

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

package/lib/index.d.ts

@@ -98,4 +98,5 @@ export * from './auctionSubscriber';
 export * from './auctionSubscriber/types';
 export * from './memcmp';
 export * from './decode/user';
+export * from './blockhashSubscriber';
 export { BN, PublicKey, pyth };

package/lib/index.js

@@ -121,3 +121,4 @@ __exportStar(require("./auctionSubscriber"), exports);
 __exportStar(require("./auctionSubscriber/types"), exports);
 __exportStar(require("./memcmp"), exports);
 __exportStar(require("./decode/user"), exports);
+__exportStar(require("./blockhashSubscriber"), exports);

package/lib/tx/baseTxSender.d.ts

@@ -22,7 +22,7 @@ export declare abstract class BaseTxSender implements TxSender {
     });
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
-    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<VersionedTransaction>;
+    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions, blockhash?: string): Promise<VersionedTransaction>;
     sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
     simulateTransaction(tx: VersionedTransaction): Promise<boolean>;

package/lib/tx/baseTxSender.js

@@ -47,16 +47,23 @@ class BaseTxSender {
         const signedTx = await this.wallet.signTransaction(tx);
         return signedTx;
     }
-    async getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners, opts) {
+    async getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners, opts, blockhash) {
         if (additionalSigners === undefined) {
             additionalSigners = [];
         }
         if (opts === undefined) {
             opts = this.opts;
         }
+        let recentBlockhash = '';
+        if (blockhash) {
+            recentBlockhash = blockhash;
+        }
+        else {
+            recentBlockhash = (await this.connection.getLatestBlockhash(opts.preflightCommitment)).blockhash;
+        }
         const message = new web3_js_1.TransactionMessage({
             payerKey: this.wallet.publicKey,
-            recentBlockhash: (await this.connection.getLatestBlockhash(opts.preflightCommitment)).blockhash,
+            recentBlockhash,
             instructions: ixs,
         }).compileToV0Message(lookupTableAccounts);
         const tx = new web3_js_1.VersionedTransaction(message);

package/lib/tx/fastSingleTxSender.d.ts

@@ -27,6 +27,6 @@ export declare class FastSingleTxSender extends BaseTxSender {
     });
     startBlockhashRefreshLoop(): void;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, _opts: ConfirmOptions): Promise<Transaction>;
-    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<VersionedTransaction>;
+    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions, blockhash?: string): Promise<VersionedTransaction>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
 }

package/lib/tx/fastSingleTxSender.js

@@ -52,7 +52,7 @@ class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
         const signedTx = await this.wallet.signTransaction(tx);
         return signedTx;
     }
-    async getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners, opts) {
+    async getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners, opts, blockhash) {
         var _a;
         if (additionalSigners === undefined) {
             additionalSigners = [];
@@ -60,10 +60,18 @@ class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
         if (opts === undefined) {
             opts = this.opts;
         }
+        let recentBlockhash = '';
+        if (blockhash) {
+            recentBlockhash = blockhash;
+        }
+        else {
+            recentBlockhash =
+                (_a = this.recentBlockhash) !== null && _a !== void 0 ? _a : (await this.connection.getLatestBlockhash(opts.preflightCommitment))
+                    .blockhash;
+        }
         const message = new web3_js_1.TransactionMessage({
             payerKey: this.wallet.publicKey,
-            recentBlockhash: (_a = this.recentBlockhash) !== null && _a !== void 0 ? _a : (await this.connection.getLatestBlockhash(opts.preflightCommitment))
-                .blockhash,
+            recentBlockhash,
             instructions: ixs,
         }).compileToV0Message(lookupTableAccounts);
         const tx = new web3_js_1.VersionedTransaction(message);

package/lib/tx/types.d.ts

@@ -17,7 +17,7 @@ export interface TxSender {
     wallet: IWallet;
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
     sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
-    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<VersionedTransaction>;
+    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions, blockhash?: string): Promise<VersionedTransaction>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
     simulateTransaction(tx: VersionedTransaction): Promise<boolean>;
     getTimeoutCount(): number;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.74.0-beta.2",
+	"version": "2.74.0-beta.4",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/blockhashSubscriber/BlockhashSubscriber.ts

@@ -0,0 +1,108 @@
+import {
+	BlockhashWithExpiryBlockHeight,
+	Commitment,
+	Connection,
+	Context,
+} from '@solana/web3.js';
+import { BlockhashSubscriberConfig } from './types';
+
+export class BlockhashSubscriber {
+	private connection: Connection;
+	private isSubscribed = false;
+	private latestBlockHeight: number;
+	private latestBlockHeightContext: Context | undefined;
+	private blockhashes: Array<BlockhashWithExpiryBlockHeight> = [];
+	private updateBlockhashIntervalId: NodeJS.Timeout | undefined;
+	private commitment: Commitment;
+	private updateIntervalMs: number;
+
+	constructor(config: BlockhashSubscriberConfig) {
+		if (!config.connection && !config.rpcUrl) {
+			throw new Error(
+				'BlockhashSubscriber requires one of connection or rpcUrl must be provided'
+			);
+		}
+		this.connection = config.connection || new Connection(config.rpcUrl!);
+		this.commitment = config.commitment ?? 'confirmed';
+		this.updateIntervalMs = config.updateIntervalMs ?? 1000;
+	}
+
+	getBlockhashCacheSize(): number {
+		return this.blockhashes.length;
+	}
+
+	getLatestBlockHeight(): number {
+		return this.latestBlockHeight;
+	}
+
+	getLatestBlockHeightContext(): Context | undefined {
+		return this.latestBlockHeightContext;
+	}
+
+	getLatestBlockhash(
+		offset?: number
+	): BlockhashWithExpiryBlockHeight | undefined {
+		if (this.blockhashes.length === 0) {
+			return undefined;
+		}
+		const clampedOffset = Math.max(
+			0,
+			Math.min(this.blockhashes.length - 1, offset ?? 0)
+		);
+
+		return this.blockhashes[this.blockhashes.length - 1 - clampedOffset];
+	}
+
+	pruneBlockhashes() {
+		if (this.latestBlockHeight) {
+			this.blockhashes = this.blockhashes.filter(
+				(blockhash) => blockhash.lastValidBlockHeight > this.latestBlockHeight!
+			);
+		}
+	}
+
+	async updateBlockhash() {
+		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);
+		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;
+	}
+}

package/src/blockhashSubscriber/index.ts

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

package/src/blockhashSubscriber/types.ts

@@ -0,0 +1,8 @@
+import { Commitment, Connection } from '@solana/web3.js';
+
+export type BlockhashSubscriberConfig = {
+	rpcUrl?: string;
+	connection?: Connection;
+	commitment?: Commitment;
+	updateIntervalMs?: number;
+};

package/src/index.ts

@@ -99,5 +99,6 @@ export * from './auctionSubscriber';
 export * from './auctionSubscriber/types';
 export * from './memcmp';
 export * from './decode/user';
+export * from './blockhashSubscriber';
 
 export { BN, PublicKey, pyth };

package/src/tx/baseTxSender.ts

@@ -112,7 +112,8 @@ export abstract class BaseTxSender implements TxSender {
 		ixs: TransactionInstruction[],
 		lookupTableAccounts: AddressLookupTableAccount[],
 		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions
+		opts?: ConfirmOptions,
+		blockhash?: string
 	): Promise<VersionedTransaction> {
 		if (additionalSigners === undefined) {
 			additionalSigners = [];
@@ -121,11 +122,18 @@ export abstract class BaseTxSender implements TxSender {
 			opts = this.opts;
 		}
 
+		let recentBlockhash = '';
+		if (blockhash) {
+			recentBlockhash = blockhash;
+		} else {
+			recentBlockhash = (
+				await this.connection.getLatestBlockhash(opts.preflightCommitment)
+			).blockhash;
+		}
+
 		const message = new TransactionMessage({
 			payerKey: this.wallet.publicKey,
-			recentBlockhash: (
-				await this.connection.getLatestBlockhash(opts.preflightCommitment)
-			).blockhash,
+			recentBlockhash,
 			instructions: ixs,
 		}).compileToV0Message(lookupTableAccounts);
 

package/src/tx/fastSingleTxSender.ts

@@ -109,7 +109,8 @@ export class FastSingleTxSender extends BaseTxSender {
 		ixs: TransactionInstruction[],
 		lookupTableAccounts: AddressLookupTableAccount[],
 		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions
+		opts?: ConfirmOptions,
+		blockhash?: string
 	): Promise<VersionedTransaction> {
 		if (additionalSigners === undefined) {
 			additionalSigners = [];
@@ -118,12 +119,19 @@ export class FastSingleTxSender extends BaseTxSender {
 			opts = this.opts;
 		}
 
-		const message = new TransactionMessage({
-			payerKey: this.wallet.publicKey,
-			recentBlockhash:
+		let recentBlockhash = '';
+		if (blockhash) {
+			recentBlockhash = blockhash;
+		} else {
+			recentBlockhash =
 				this.recentBlockhash ??
 				(await this.connection.getLatestBlockhash(opts.preflightCommitment))
-					.blockhash,
+					.blockhash;
+		}
+
+		const message = new TransactionMessage({
+			payerKey: this.wallet.publicKey,
+			recentBlockhash,
 			instructions: ixs,
 		}).compileToV0Message(lookupTableAccounts);
 

package/src/tx/types.ts

@@ -47,7 +47,8 @@ export interface TxSender {
 		ixs: TransactionInstruction[],
 		lookupTableAccounts: AddressLookupTableAccount[],
 		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions
+		opts?: ConfirmOptions,
+		blockhash?: string
 	): Promise<VersionedTransaction>;
 
 	sendRawTransaction(

package/tests/amm/test.ts

@@ -1193,7 +1193,9 @@ describe('AMM Tests', () => {
 		};
 
 		// good oracle
-		assert(isOracleValid(mockMarket1, oraclePriceData, oracleGuardRails, slot + 5));
+		assert(
+			isOracleValid(mockMarket1, oraclePriceData, oracleGuardRails, slot + 5)
+		);
 
 		// conf too high
 		assert(