@drift-labs/sdk-browser 2.104.0-beta.21

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/pythOracleUtils.d.ts

@@ -0,0 +1,17 @@
+import { TransactionInstruction } from '@solana/web3.js';
+export declare function trimFeedId(feedId: string): string;
+export declare function getFeedIdUint8Array(feedId: string): Uint8Array;
+export declare function getEd25519ArgsFromHex(hex: string): {
+    publicKey: Uint8Array;
+    signature: Uint8Array;
+    message: Uint8Array;
+};
+/**
+ * Constructs a minimal Ed25519 verification instruction that references the data
+ * inside the main instruction (postPythLazerOracleUpdate).
+ *
+ * @param customInstructionIndex The index of the custom instruction in the transaction (typically 1 if this is second).
+ * @param messageOffset The offset within the custom instruction data where the pythMessage begins.
+ * @param customInstructionData The entire instruction data array for the custom instruction.
+ */
+export declare function createMinimalEd25519VerifyIx(customInstructionIndex: number, messageOffset: number, customInstructionData: Uint8Array): TransactionInstruction;

package/lib/node/util/pythOracleUtils.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMinimalEd25519VerifyIx = exports.getEd25519ArgsFromHex = exports.getFeedIdUint8Array = exports.trimFeedId = void 0;
+const web3_js_1 = require("@solana/web3.js");
+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;
+const SIGNATURE_LEN = 64;
+const PUBKEY_LEN = 32;
+const MAGIC_LEN = 4;
+const MESSAGE_SIZE_LEN = 2;
+function getEd25519ArgsFromHex(hex) {
+    const cleanedHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+    const buffer = new Uint8Array(Buffer.from(cleanedHex, 'hex'));
+    const signatureOffset = MAGIC_LEN;
+    const publicKeyOffset = signatureOffset + SIGNATURE_LEN;
+    const messageDataSizeOffset = publicKeyOffset + PUBKEY_LEN;
+    const messageDataOffset = messageDataSizeOffset + MESSAGE_SIZE_LEN;
+    const signature = buffer.slice(signatureOffset, signatureOffset + SIGNATURE_LEN);
+    const publicKey = buffer.slice(publicKeyOffset, publicKeyOffset + PUBKEY_LEN);
+    const messageSize = buffer[messageDataSizeOffset] | (buffer[messageDataSizeOffset + 1] << 8);
+    const message = buffer.slice(messageDataOffset, messageDataOffset + messageSize);
+    if (publicKey.length !== PUBKEY_LEN) {
+        throw new Error('Invalid public key length');
+    }
+    if (signature.length !== SIGNATURE_LEN) {
+        throw new Error('Invalid signature length');
+    }
+    return {
+        publicKey,
+        signature,
+        message,
+    };
+}
+exports.getEd25519ArgsFromHex = getEd25519ArgsFromHex;
+/**
+ * Constructs a minimal Ed25519 verification instruction that references the data
+ * inside the main instruction (postPythLazerOracleUpdate).
+ *
+ * @param customInstructionIndex The index of the custom instruction in the transaction (typically 1 if this is second).
+ * @param messageOffset The offset within the custom instruction data where the pythMessage begins.
+ * @param customInstructionData The entire instruction data array for the custom instruction.
+ */
+function createMinimalEd25519VerifyIx(customInstructionIndex, messageOffset, customInstructionData) {
+    const signatureOffset = messageOffset + MAGIC_LEN;
+    const publicKeyOffset = signatureOffset + SIGNATURE_LEN;
+    const messageDataSizeOffset = publicKeyOffset + PUBKEY_LEN;
+    const messageDataOffset = messageDataSizeOffset + MESSAGE_SIZE_LEN;
+    if (messageDataOffset > customInstructionData.length) {
+        throw new Error('Not enough data in main instruction to read message size');
+    }
+    const messageSize = customInstructionData[messageDataSizeOffset] |
+        (customInstructionData[messageDataSizeOffset + 1] << 8);
+    // Construct Ed25519SignatureOffsets
+    // struct Ed25519SignatureOffsets (14 bytes):
+    // u16 signature_offset
+    // u16 signature_instruction_index
+    // u16 public_key_offset
+    // u16 public_key_instruction_index
+    // u16 message_data_offset
+    // u16 message_data_size
+    // u16 message_instruction_index
+    const offsets = new Uint8Array(14);
+    const dv = new DataView(offsets.buffer);
+    let byteOffset = 0;
+    dv.setUint16(byteOffset, signatureOffset, true);
+    byteOffset += 2;
+    dv.setUint16(byteOffset, customInstructionIndex, true);
+    byteOffset += 2;
+    dv.setUint16(byteOffset, publicKeyOffset, true);
+    byteOffset += 2;
+    dv.setUint16(byteOffset, customInstructionIndex, true);
+    byteOffset += 2;
+    dv.setUint16(byteOffset, messageDataOffset, true);
+    byteOffset += 2;
+    dv.setUint16(byteOffset, messageSize, true);
+    byteOffset += 2;
+    dv.setUint16(byteOffset, customInstructionIndex, true);
+    byteOffset += 2;
+    const numSignatures = 1;
+    const padding = 0;
+    const ixData = new Uint8Array(2 + offsets.length);
+    ixData[0] = numSignatures;
+    ixData[1] = padding;
+    ixData.set(offsets, 2);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            {
+                pubkey: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+                isSigner: false,
+                isWritable: false,
+            },
+        ],
+        programId: web3_js_1.Ed25519Program.programId,
+        data: Buffer.from(ixData),
+    });
+}
+exports.createMinimalEd25519VerifyIx = createMinimalEd25519VerifyIx;

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;

package/lib/node/wallet.d.ts

@@ -0,0 +1,11 @@
+import { Keypair, PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
+import { IWallet, IVersionedWallet } from './types';
+export declare class Wallet implements IWallet, IVersionedWallet {
+    readonly payer: Keypair;
+    constructor(payer: Keypair);
+    signTransaction(tx: Transaction): Promise<Transaction>;
+    signVersionedTransaction(tx: VersionedTransaction): Promise<VersionedTransaction>;
+    signAllTransactions(txs: Transaction[]): Promise<Transaction[]>;
+    signAllVersionedTransactions(txs: VersionedTransaction[]): Promise<VersionedTransaction[]>;
+    get publicKey(): PublicKey;
+}

package/lib/node/wallet.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Wallet = void 0;
+class Wallet {
+    constructor(payer) {
+        this.payer = payer;
+    }
+    async signTransaction(tx) {
+        tx.partialSign(this.payer);
+        return tx;
+    }
+    async signVersionedTransaction(tx) {
+        tx.sign([this.payer]);
+        return tx;
+    }
+    async signAllTransactions(txs) {
+        return txs.map((t) => {
+            t.partialSign(this.payer);
+            return t;
+        });
+    }
+    async signAllVersionedTransactions(txs) {
+        return txs.map((t) => {
+            t.sign([this.payer]);
+            return t;
+        });
+    }
+    get publicKey() {
+        return this.payer.publicKey;
+    }
+}
+exports.Wallet = Wallet;

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@drift-labs/sdk-browser",
+  "version": "2.104.0-beta.21",
+  "main": "lib/node/index.js",
+  "types": "lib/node/index.d.ts",
+  "browser": "./lib/browser/index.js",
+  "author": "crispheaney",
+  "homepage": "https://www.drift.trade/",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:drift-labs/protocol-v2.git"
+  },
+  "scripts": {
+    "lint": "eslint './**/*.{ts,tsx}' --quiet",
+    "build": "yarn clean && tsc -p tsconfig.json && tsc -p tsconfig.browser.json && node scripts/postbuild.js",
+    "build:browser": "yarn clean && tsc -p tsconfig.json && tsc -p tsconfig.browser.json && node scripts/postbuild.js --force-env browser",
+    "clean": "rm -rf lib",
+    "test": "mocha -r ts-node/register tests/**/*.ts",
+    "test:inspect": "mocha --inspect-brk -r ts-node/register tests/**/*.ts",
+    "test:bignum": "mocha -r ts-node/register tests/bn/**/*.ts",
+    "patch-and-pub": "npm version patch --force && npm publish",
+    "prettify": "prettier --check './src/***/*.ts'",
+    "prettify:fix": "prettier --write './{src,tests}/***/*.ts'",
+    "version": "node ./scripts/updateVersion.js"
+  },
+  "keywords": [
+    "drift-labs",
+    "drift",
+    "perps"
+  ],
+  "license": "Apache-2.0",
+  "directories": {
+    "lib": "lib"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "0.29.0",
+    "@coral-xyz/anchor-30": "npm:@coral-xyz/anchor@0.30.1",
+    "@ellipsis-labs/phoenix-sdk": "1.4.5",
+    "@grpc/grpc-js": "^1.8.0",
+    "@openbook-dex/openbook-v2": "0.2.10",
+    "@project-serum/serum": "0.13.65",
+    "@pythnetwork/client": "2.5.3",
+    "@pythnetwork/price-service-sdk": "1.7.1",
+    "@pythnetwork/pyth-solana-receiver": "0.7.0",
+    "@solana/spl-token": "0.3.7",
+    "@solana/web3.js": "1.92.3",
+    "@switchboard-xyz/on-demand": "1.2.42",
+    "@triton-one/yellowstone-grpc": "1.3.0",
+    "anchor-bankrun": "0.3.0",
+    "node-cache": "5.1.2",
+    "rpc-websockets": "7.5.1",
+    "solana-bankrun": "0.3.1",
+    "strict-event-emitter-types": "2.0.0",
+    "tweetnacl": "1.0.3",
+    "uuid": "8.3.2",
+    "yargs": "17.7.2",
+    "zstddec": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/big.js": "6.2.2",
+    "@types/bn.js": "5.1.6",
+    "@types/bs58": "4.0.4",
+    "@types/chai": "4.3.20",
+    "@types/jest": "28.1.8",
+    "@types/mocha": "9.1.1",
+    "@typescript-eslint/eslint-plugin": "4.28.0",
+    "@typescript-eslint/parser": "4.28.0",
+    "chai": "4.5.0",
+    "encoding": "0.1.13",
+    "eslint": "7.29.0",
+    "eslint-config-prettier": "8.3.0",
+    "eslint-plugin-prettier": "3.4.0",
+    "lodash": "4.17.21",
+    "mocha": "10.7.3",
+    "object-sizeof": "2.6.5",
+    "prettier": "3.0.1",
+    "sinon": "18.0.1",
+    "ts-node": "10.9.2",
+    "typescript": "4.9.5"
+  },
+  "description": "SDK for Drift Protocol",
+  "engines": {
+    "node": ">=20.18.0"
+  },
+  "resolutions": {
+    "@solana/errors": "2.0.0-preview.4",
+    "@solana/codecs-data-structures": "2.0.0-preview.4"
+  }
+}

package/scripts/postbuild.js

@@ -0,0 +1,95 @@
+// scripts/postbuild.js
+const fs = require('fs');
+const path = require('path');
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+
+const forceEnv = yargs(hideBin(process.argv))
+	.option('force-env', {
+		type: 'string',
+		description: 'Specify environment to force (node or browser)',
+		choices: ['node', 'browser']
+	})
+	.argv?.forceEnv;
+
+const isomorphicPackages = ['grpc'];
+const environments = ['node', 'browser'];
+
+environments.forEach((environment) => {
+	console.log(`Running ${environment} environment postbuild script`);
+	console.log(``);
+
+	isomorphicPackages.forEach((package) => {
+
+		// We want to overwrite the base isomorphic files (the "target" files) with the concrete implementation code and definition files (the "source" files).
+
+		const isomorphicFolderPath = path.join(
+			__dirname,
+			'..',
+			'lib',
+			environment,
+			'isomorphic'
+		);
+
+		const targetEnv = forceEnv ? forceEnv : environment;
+
+		const filesToSwap = [
+			{
+				source: `${package}.${targetEnv}.js`,
+				target: `${package}.js`,
+			},
+			{
+				source: `${package}.${targetEnv}.d.ts`,
+				target: `${package}.d.ts`,
+			},
+		];
+
+		for (const file of filesToSwap) {
+			const sourcePath = path.join(
+				isomorphicFolderPath,
+				file.source
+			);
+
+			const targetPath = path.join(
+				isomorphicFolderPath,
+				file.target
+			);
+
+			try {
+				const sourceContent = fs.readFileSync(sourcePath, 'utf8');
+				fs.writeFileSync(targetPath, sourceContent);
+			} catch (error) {
+				console.error(
+					`Error processing isomophic package : ${package} :: ${error.message}`
+				);
+			}
+		}
+
+		// Delete other environment files for safety
+		environments.forEach((otherEnvironment) => {
+			if (otherEnvironment === targetEnv) {
+				return;
+			}
+
+			const otherTargetFiles = [
+				`${package}.${otherEnvironment}.js`,
+				`${package}.${otherEnvironment}.d.ts`,
+			];
+
+			for (const otherTargetFile of otherTargetFiles) {
+				const otherTargetPath = path.join(
+					__dirname,
+					'..',
+					'lib',
+					environment,
+					'isomorphic',
+					otherTargetFile
+				);
+
+				if (fs.existsSync(otherTargetPath)) {
+					fs.unlinkSync(otherTargetPath);
+				}
+			}
+		});
+	});
+});

package/scripts/updateVersion.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+const packageJson = require('../package.json');
+
+const versionFilePath = path.join(__dirname, '..', 'VERSION');
+
+let version = fs.readFileSync(versionFilePath, 'utf8');
+version = version.replace(/\n/g, '');
+
+const filesToReplace = [
+    // sdk/src/idl/drift.json
+    path.join(__dirname, '..', 'src', 'idl', 'drift.json'),
+    // programs/drift/Cargo.toml
+    path.join(__dirname, '..', '..', 'programs', 'drift', 'Cargo.toml'),
+    // Cargo.lock
+    path.join(__dirname, '..', '..', 'Cargo.lock'),
+]
+
+console.log(`Updating versions from ${version} to ${packageJson.version} in:`);
+for (const file of filesToReplace) {
+    console.log(`* ${file}`);
+    const fileContents = fs.readFileSync(file, 'utf8');
+    const newFileContents = fileContents.replace(version, packageJson.version);
+    fs.writeFileSync(file, newFileContents);
+}
+
+fs.writeFileSync(versionFilePath, packageJson.version);
+console.log("");

package/src/accounts/basicUserAccountSubscriber.ts

@@ -0,0 +1,59 @@
+import { DataAndSlot, UserAccountEvents, UserAccountSubscriber } from './types';
+import { PublicKey } from '@solana/web3.js';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { UserAccount } from '../types';
+
+/**
+ * Basic implementation of UserAccountSubscriber. It will only take in UserAccount
+ * data during initialization and will not fetch or subscribe to updates.
+ */
+export class BasicUserAccountSubscriber implements UserAccountSubscriber {
+	isSubscribed: boolean;
+	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+	userAccountPublicKey: PublicKey;
+
+	callbackId?: string;
+	errorCallbackId?: string;
+
+	user: DataAndSlot<UserAccount>;
+
+	public constructor(
+		userAccountPublicKey: PublicKey,
+		data?: UserAccount,
+		slot?: number
+	) {
+		this.isSubscribed = true;
+		this.eventEmitter = new EventEmitter();
+		this.userAccountPublicKey = userAccountPublicKey;
+		this.user = { data, slot };
+	}
+
+	async subscribe(_userAccount?: UserAccount): Promise<boolean> {
+		return true;
+	}
+
+	async addToAccountLoader(): Promise<void> {}
+
+	async fetch(): Promise<void> {}
+
+	doesAccountExist(): boolean {
+		return this.user !== undefined;
+	}
+
+	async unsubscribe(): Promise<void> {}
+
+	assertIsSubscribed(): void {}
+
+	public getUserAccountAndSlot(): DataAndSlot<UserAccount> {
+		return this.user;
+	}
+
+	public updateData(userAccount: UserAccount, slot: number): void {
+		if (!this.user || slot >= (this.user.slot ?? 0)) {
+			this.user = { data: userAccount, slot };
+			this.eventEmitter.emit('userAccountUpdate', userAccount);
+			this.eventEmitter.emit('update');
+		}
+	}
+}