@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.30

package/src/userMap/userMap.ts

@@ -0,0 +1,100 @@
+import {
+	ClearingHouseUser,
+	ClearingHouse,
+	UserAccount,
+	bulkPollingUserSubscribe,
+	OrderRecord,
+	ClearingHouseUserAccountSubscriptionConfig,
+} from '..';
+import { ProgramAccount } from '@project-serum/anchor';
+
+import { PublicKey } from '@solana/web3.js';
+
+export class UserMap {
+	private userMap = new Map<string, ClearingHouseUser>();
+	private clearingHouse: ClearingHouse;
+	private accountSubscription: ClearingHouseUserAccountSubscriptionConfig;
+
+	constructor(
+		clearingHouse: ClearingHouse,
+		accountSubscription: ClearingHouseUserAccountSubscriptionConfig
+	) {
+		this.clearingHouse = clearingHouse;
+		this.accountSubscription = accountSubscription;
+	}
+
+	public async fetchAllUsers() {
+		const userArray: ClearingHouseUser[] = [];
+
+		const programUserAccounts =
+			(await this.clearingHouse.program.account.user.all()) as ProgramAccount<UserAccount>[];
+		for (const programUserAccount of programUserAccounts) {
+			if (this.userMap.has(programUserAccount.publicKey.toString())) {
+				continue;
+			}
+
+			const user = new ClearingHouseUser({
+				clearingHouse: this.clearingHouse,
+				userAccountPublicKey: programUserAccount.publicKey,
+				accountSubscription: this.accountSubscription,
+			});
+			userArray.push(user);
+		}
+
+		if (this.accountSubscription.type === 'polling') {
+			await bulkPollingUserSubscribe(
+				userArray,
+				this.accountSubscription.accountLoader
+			);
+		}
+
+		for (const user of userArray) {
+			this.userMap.set(user.getUserAccountPublicKey().toString(), user);
+		}
+	}
+
+	public async addPubkey(userAccountPublicKey: PublicKey) {
+		const user = new ClearingHouseUser({
+			clearingHouse: this.clearingHouse,
+			userAccountPublicKey,
+			accountSubscription: this.accountSubscription,
+		});
+		await user.subscribe();
+		this.userMap.set(userAccountPublicKey.toString(), user);
+	}
+
+	public has(key: string): boolean {
+		return this.userMap.has(key);
+	}
+
+	/**
+	 * gets the ClearingHouseUser for a particular userAccountPublicKey, if no ClearingHouseUser exists, undefined is returned
+	 * @param key userAccountPublicKey to get ClearngHouseUserFor
+	 * @returns user ClearingHouseUser | undefined
+	 */
+	public get(key: string): ClearingHouseUser | undefined {
+		return this.userMap.get(key);
+	}
+
+	/**
+	 * gets the ClearingHouseUser for a particular userAccountPublicKey, if no ClearingHouseUser exists, new one is created
+	 * @param key userAccountPublicKey to get ClearngHouseUserFor
+	 * @returns  ClearingHouseUser
+	 */
+	public async mustGet(key: string): Promise<ClearingHouseUser> {
+		if (!this.has(key)) {
+			await this.addPubkey(new PublicKey(key));
+		}
+		const user = this.userMap.get(key);
+		await user.fetchAccounts();
+		return user;
+	}
+
+	public async updateWithOrderRecord(record: OrderRecord) {
+		await this.addPubkey(record.user);
+	}
+
+	public values(): IterableIterator<ClearingHouseUser> {
+		return this.userMap.values();
+	}
+}

package/src/userMap/userStatsMap.ts

@@ -0,0 +1,110 @@
+import {
+	ClearingHouse,
+	getUserStatsAccountPublicKey,
+	OrderRecord,
+	UserStatsAccount,
+	ClearingHouseUserStats,
+	ClearingHouseUserStatsAccountSubscriptionConfig,
+	bulkPollingUserStatsSubscribe,
+} from '..';
+import { ProgramAccount } from '@project-serum/anchor';
+import { PublicKey } from '@solana/web3.js';
+
+import { UserMap } from './userMap';
+
+export class UserStatsMap {
+	/**
+	 * map from authority pubkey to ClearingHouseUserStats
+	 */
+	private userStatsMap = new Map<string, ClearingHouseUserStats>();
+	private clearingHouse: ClearingHouse;
+	private accountSubscription: ClearingHouseUserStatsAccountSubscriptionConfig;
+
+	constructor(
+		clearingHouse: ClearingHouse,
+		accountSubscription: ClearingHouseUserStatsAccountSubscriptionConfig
+	) {
+		this.clearingHouse = clearingHouse;
+		this.accountSubscription = accountSubscription;
+	}
+
+	public async fetchAllUserStats() {
+		const userStatArray: ClearingHouseUserStats[] = [];
+
+		const programUserAccounts =
+			(await this.clearingHouse.program.account.userStats.all()) as ProgramAccount<UserStatsAccount>[];
+
+		for (const programUserAccount of programUserAccounts) {
+			const userStat: UserStatsAccount = programUserAccount.account;
+			if (this.userStatsMap.has(userStat.authority.toString())) {
+				continue;
+			}
+
+			const chUserStat = new ClearingHouseUserStats({
+				clearingHouse: this.clearingHouse,
+				userStatsAccountPublicKey: getUserStatsAccountPublicKey(
+					this.clearingHouse.program.programId,
+					userStat.authority
+				),
+				accountSubscription: this.accountSubscription,
+			});
+			userStatArray.push(chUserStat);
+		}
+
+		if (this.accountSubscription.type === 'polling') {
+			await bulkPollingUserStatsSubscribe(
+				userStatArray,
+				this.accountSubscription.accountLoader
+			);
+		}
+
+		for (const userStat of userStatArray) {
+			this.userStatsMap.set(
+				userStat.getAccount().authority.toString(),
+				userStat
+			);
+		}
+	}
+
+	public async addUserStat(authority: PublicKey) {
+		const userStat = new ClearingHouseUserStats({
+			clearingHouse: this.clearingHouse,
+			userStatsAccountPublicKey: getUserStatsAccountPublicKey(
+				this.clearingHouse.program.programId,
+				authority
+			),
+			accountSubscription: this.accountSubscription,
+		});
+		await userStat.subscribe();
+
+		this.userStatsMap.set(authority.toString(), userStat);
+	}
+
+	public async updateWithOrderRecord(record: OrderRecord, userMap: UserMap) {
+		if (!this.has(record.user.toString())) {
+			const takerUserAccount = await userMap.mustGet(record.user.toString());
+			this.addUserStat(takerUserAccount.getUserAccount().authority);
+		}
+	}
+
+	public has(authorityPublicKey: string): boolean {
+		return this.userStatsMap.has(authorityPublicKey);
+	}
+
+	public get(authorityPublicKey: string): ClearingHouseUserStats {
+		return this.userStatsMap.get(authorityPublicKey);
+	}
+
+	public async mustGet(
+		authorityPublicKey: string
+	): Promise<ClearingHouseUserStats> {
+		if (!this.has(authorityPublicKey)) {
+			await this.addUserStat(new PublicKey(authorityPublicKey));
+		}
+		return this.get(authorityPublicKey);
+	}
+
+	public values(): IterableIterator<ClearingHouseUserStats> {
+		return this.userStatsMap.values();
+	}
+}

package/src/util/computeUnits.js

@@ -1,17 +1,27 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findComputeUnitConsumption = void 0;
-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 200000 compute units`);
-    tx.meta.logMessages.forEach((logMessage) => {
-        const match = logMessage.match(regex);
-        if (match && match[1]) {
-            computeUnits.push(match[1]);
-        }
+function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tx = yield 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;
     });
-    return computeUnits;
 }
 exports.findComputeUnitConsumption = findComputeUnitConsumption;
-//# sourceMappingURL=computeUnits.js.map

package/src/util/computeUnits.ts

@@ -9,7 +9,7 @@ export async function findComputeUnitConsumption(
 	const tx = await connection.getTransaction(txSignature, { commitment });
 	const computeUnits = [];
 	const regex = new RegExp(
-		`Program ${programId.toString()} consumed ([0-9]{0,6}) of 200000 compute units`
+		`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);

package/src/util/getTokenAddress.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenAddress = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const getTokenAddress = (mintAddress, userPubKey) => {
+    return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
+};
+exports.getTokenAddress = getTokenAddress;

package/src/util/getTokenAddress.ts

@@ -0,0 +1,18 @@
+import {
+	Token,
+	ASSOCIATED_TOKEN_PROGRAM_ID,
+	TOKEN_PROGRAM_ID,
+} from '@solana/spl-token';
+import { PublicKey } from '@solana/web3.js';
+
+export const getTokenAddress = (
+	mintAddress: string,
+	userPubKey: string
+): Promise<PublicKey> => {
+	return Token.getAssociatedTokenAddress(
+		ASSOCIATED_TOKEN_PROGRAM_ID,
+		TOKEN_PROGRAM_ID,
+		new PublicKey(mintAddress),
+		new PublicKey(userPubKey)
+	);
+};

package/src/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/src/util/tps.js

@@ -0,0 +1,27 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTps = void 0;
+function estimateTps(programId, connection, failed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let signatures = yield 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/tests/bn/test.ts

@@ -70,8 +70,7 @@ describe('BigNum Tests', () => {
 
 		expect(val.print()).to.equal('1234.56789');
 
-		expect(val.toFixed(3)).to.equal('1234.567');
-
+		expect(val.toNum().toFixed(3)).to.equal('1234.568');
 		expect(val.toPrecision(1)).to.equal('1e3');
 		expect(val.toPrecision(3)).to.equal('123e1');
 		expect(val.toPrecision(4)).to.equal('1234');
@@ -102,7 +101,7 @@ describe('BigNum Tests', () => {
 
 		expect(val4.toString()).to.equal('250000000000');
 		expect(val4.print()).to.equal('0.0250000000000');
-		expect(val4.toFixed(3)).to.equal('0.025');
+		expect(val4.toNum().toFixed(3)).to.equal('0.025');
 		expect(val4.toPrecision(4)).to.equal('0.025');
 
 		// Case 5
@@ -125,6 +124,16 @@ describe('BigNum Tests', () => {
 		expect(BigNum.fromPrint('1234567').toMillified(5)).to.equal('1.2345M');
 		expect(BigNum.fromPrint('12345678').toMillified(5)).to.equal('12.345M');
 		expect(BigNum.fromPrint('123456789').toMillified(5)).to.equal('123.45M');
+
+		expect(BigNum.from(-95, 2).print()).to.equal('-0.95');
+
+		// Case 6 strange numbers
+		expect(BigNum.from('-100', 2).print()).to.equal('-1.00');
+		expect(BigNum.from('-8402189', 13).print()).to.equal('-0.0000008402189');
+		expect(BigNum.from('-10000000000000', 13).print()).to.equal(
+			'-1.0000000000000'
+		);
+		expect(BigNum.from('-100', 6).print()).to.equal('-0.000100');
 	});
 
 	it('can initialise from string values correctly', () => {