@drift-labs/sdk 0.2.0-master.4 → 0.2.0-master.40

package/src/{clearingHouseUserConfig.ts → userConfig.ts}

@@ -1,14 +1,14 @@
-import { ClearingHouse } from './clearingHouse';
+import { DriftClient } from './driftClient';
 import { PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
 
-export type ClearingHouseUserConfig = {
-	accountSubscription?: ClearingHouseUserAccountSubscriptionConfig;
-	clearingHouse: ClearingHouse;
+export type UserConfig = {
+	accountSubscription?: UserSubscriptionConfig;
+	driftClient: DriftClient;
 	userAccountPublicKey: PublicKey;
 };
 
-export type ClearingHouseUserAccountSubscriptionConfig =
+export type UserSubscriptionConfig =
 	| {
 			type: 'websocket';
 	  }

package/src/userMap/userMap.ts

@@ -0,0 +1,124 @@
+import {
+	User,
+	DriftClient,
+	UserAccount,
+	bulkPollingUserSubscribe,
+	OrderRecord,
+	UserSubscriptionConfig,
+} from '..';
+import { ProgramAccount } from '@project-serum/anchor';
+
+import { PublicKey } from '@solana/web3.js';
+
+export interface UserMapInterface {
+	fetchAllUsers(): Promise<void>;
+	addPubkey(userAccountPublicKey: PublicKey): Promise<void>;
+	has(key: string): boolean;
+	get(key: string): User | undefined;
+	mustGet(key: string): Promise<User>;
+	getUserAuthority(key: string): PublicKey | undefined;
+	updateWithOrderRecord(record: OrderRecord): Promise<void>;
+	values(): IterableIterator<User>;
+}
+
+export class UserMap implements UserMapInterface {
+	private userMap = new Map<string, User>();
+	private driftClient: DriftClient;
+	private accountSubscription: UserSubscriptionConfig;
+
+	constructor(
+		driftClient: DriftClient,
+		accountSubscription: UserSubscriptionConfig
+	) {
+		this.driftClient = driftClient;
+		this.accountSubscription = accountSubscription;
+	}
+
+	public async fetchAllUsers() {
+		const userArray: User[] = [];
+
+		const programUserAccounts =
+			(await this.driftClient.program.account.user.all()) as ProgramAccount<UserAccount>[];
+		for (const programUserAccount of programUserAccounts) {
+			if (this.userMap.has(programUserAccount.publicKey.toString())) {
+				continue;
+			}
+
+			const user = new User({
+				driftClient: this.driftClient,
+				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 User({
+			driftClient: this.driftClient,
+			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 User for a particular userAccountPublicKey, if no User exists, undefined is returned
+	 * @param key userAccountPublicKey to get User for
+	 * @returns user User | undefined
+	 */
+	public get(key: string): User | undefined {
+		return this.userMap.get(key);
+	}
+
+	/**
+	 * gets the User for a particular userAccountPublicKey, if no User exists, new one is created
+	 * @param key userAccountPublicKey to get User for
+	 * @returns  User
+	 */
+	public async mustGet(key: string): Promise<User> {
+		if (!this.has(key)) {
+			await this.addPubkey(new PublicKey(key));
+		}
+		const user = this.userMap.get(key);
+		await user.fetchAccounts();
+		return user;
+	}
+
+	/**
+	 * gets the Authority for a particular userAccountPublicKey, if no User exists, undefined is returned
+	 * @param key userAccountPublicKey to get User for
+	 * @returns authority PublicKey | undefined
+	 */
+	public getUserAuthority(key: string): PublicKey | undefined {
+		const chUser = this.userMap.get(key);
+		if (!chUser) {
+			return undefined;
+		}
+		return chUser.getUserAccount().authority;
+	}
+
+	public async updateWithOrderRecord(record: OrderRecord) {
+		await this.addPubkey(record.user);
+	}
+
+	public values(): IterableIterator<User> {
+		return this.userMap.values();
+	}
+}

package/src/userMap/userStatsMap.ts

@@ -0,0 +1,108 @@
+import {
+	DriftClient,
+	getUserStatsAccountPublicKey,
+	OrderRecord,
+	UserStatsAccount,
+	UserStats,
+	UserStatsSubscriptionConfig,
+	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 UserStats
+	 */
+	private userStatsMap = new Map<string, UserStats>();
+	private driftClient: DriftClient;
+	private accountSubscription: UserStatsSubscriptionConfig;
+
+	constructor(
+		driftClient: DriftClient,
+		accountSubscription: UserStatsSubscriptionConfig
+	) {
+		this.driftClient = driftClient;
+		this.accountSubscription = accountSubscription;
+	}
+
+	public async fetchAllUserStats() {
+		const userStatArray: UserStats[] = [];
+
+		const programUserAccounts =
+			(await this.driftClient.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 UserStats({
+				driftClient: this.driftClient,
+				userStatsAccountPublicKey: getUserStatsAccountPublicKey(
+					this.driftClient.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 UserStats({
+			driftClient: this.driftClient,
+			userStatsAccountPublicKey: getUserStatsAccountPublicKey(
+				this.driftClient.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): UserStats {
+		return this.userStatsMap.get(authorityPublicKey);
+	}
+
+	public async mustGet(authorityPublicKey: string): Promise<UserStats> {
+		if (!this.has(authorityPublicKey)) {
+			await this.addUserStat(new PublicKey(authorityPublicKey));
+		}
+		return this.get(authorityPublicKey);
+	}
+
+	public values(): IterableIterator<UserStats> {
+		return this.userStatsMap.values();
+	}
+}

package/src/userName.ts

@@ -1,10 +1,11 @@
 export const MAX_NAME_LENGTH = 32;
 
 export const DEFAULT_USER_NAME = 'Main Account';
+export const DEFAULT_MARKET_NAME = 'Default Market Name';
 
 export function encodeName(name: string): number[] {
 	if (name.length > MAX_NAME_LENGTH) {
-		throw Error(`User name (${name}) longer than 32 characters`);
+		throw Error(`Name (${name}) longer than 32 characters`);
 	}
 
 	const buffer = Buffer.alloc(32);

package/src/userStats.ts

@@ -0,0 +1,75 @@
+import { DriftClient } from './driftClient';
+import { PublicKey } from '@solana/web3.js';
+import { DataAndSlot, UserStatsAccountSubscriber } from './accounts/types';
+import { UserStatsConfig } from './userStatsConfig';
+import { PollingUserStatsAccountSubscriber } from './accounts/pollingUserStatsAccountSubscriber';
+import { WebSocketUserStatsAccountSubscriber } from './accounts/webSocketUserStatsAccountSubsriber';
+import { ReferrerInfo, UserStatsAccount } from './types';
+import {
+	getUserAccountPublicKeySync,
+	getUserStatsAccountPublicKey,
+} from './addresses/pda';
+
+export class UserStats {
+	driftClient: DriftClient;
+	userStatsAccountPublicKey: PublicKey;
+	accountSubscriber: UserStatsAccountSubscriber;
+	isSubscribed: boolean;
+
+	public constructor(config: UserStatsConfig) {
+		this.driftClient = config.driftClient;
+		this.userStatsAccountPublicKey = config.userStatsAccountPublicKey;
+		if (config.accountSubscription?.type === 'polling') {
+			this.accountSubscriber = new PollingUserStatsAccountSubscriber(
+				config.driftClient.program,
+				config.userStatsAccountPublicKey,
+				config.accountSubscription.accountLoader
+			);
+		} else {
+			this.accountSubscriber = new WebSocketUserStatsAccountSubscriber(
+				config.driftClient.program,
+				config.userStatsAccountPublicKey
+			);
+		}
+	}
+
+	public async subscribe(): Promise<boolean> {
+		this.isSubscribed = await this.accountSubscriber.subscribe();
+		return this.isSubscribed;
+	}
+
+	public async fetchAccounts(): Promise<void> {
+		await this.accountSubscriber.fetch();
+	}
+
+	public async unsubscribe(): Promise<void> {
+		await this.accountSubscriber.unsubscribe();
+		this.isSubscribed = false;
+	}
+
+	public getAccountAndSlot(): DataAndSlot<UserStatsAccount> {
+		return this.accountSubscriber.getUserStatsAccountAndSlot();
+	}
+
+	public getAccount(): UserStatsAccount {
+		return this.accountSubscriber.getUserStatsAccountAndSlot().data;
+	}
+
+	public getReferrerInfo(): ReferrerInfo | undefined {
+		if (this.getAccount().referrer.equals(PublicKey.default)) {
+			return undefined;
+		} else {
+			return {
+				referrer: getUserAccountPublicKeySync(
+					this.driftClient.program.programId,
+					this.getAccount().referrer,
+					0
+				),
+				referrerStats: getUserStatsAccountPublicKey(
+					this.driftClient.program.programId,
+					this.getAccount().referrer
+				),
+			};
+		}
+	}
+}

package/src/userStatsConfig.ts

@@ -0,0 +1,18 @@
+import { DriftClient } from './driftClient';
+import { PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+
+export type UserStatsConfig = {
+	accountSubscription?: UserStatsSubscriptionConfig;
+	driftClient: DriftClient;
+	userStatsAccountPublicKey: PublicKey;
+};
+
+export type UserStatsSubscriptionConfig =
+	| {
+			type: 'websocket';
+	  }
+	| {
+			type: 'polling';
+			accountLoader: BulkAccountLoader;
+	  };

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.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/tests/bn/test.ts

@@ -1,4 +1,4 @@
-import { BN } from '@project-serum/anchor';
+import { BN } from '../../src/index';
 import { expect } from 'chai';
 import { BigNum } from '../../src/factory/bigNum';
 import {
@@ -6,6 +6,7 @@ import {
 	BASE_PRECISION_EXP,
 	TEN_THOUSAND,
 } from '../../src/constants/numericConstants';
+
 // if you used the '@types/mocha' method to install mocha type definitions, uncomment the following line
 // import 'mocha';
 
@@ -70,14 +71,15 @@ 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');
 		expect(val.toPrecision(5)).to.equal('1234.5');
 		expect(val.toPrecision(11)).to.equal('1234.5678900');
 
+		expect(BigNum.from('1234').toPrecision(5)).to.equal('1234.0');
+
 		// Case 2
 		const val2 = BigNum.from(1, 5);
 
@@ -100,9 +102,9 @@ describe('BigNum Tests', () => {
 			.shift(AMM_RESERVE_PRECISION_EXP)
 			.div(BigNum.from(entryPriceNum * 10 ** 8));
 
-		expect(val4.toString()).to.equal('250000000000');
-		expect(val4.print()).to.equal('0.0250000000000');
-		expect(val4.toFixed(3)).to.equal('0.025');
+		expect(val4.toString()).to.equal('25000000');
+		expect(val4.print()).to.equal('0.025000000');
+		expect(val4.toNum().toFixed(3)).to.equal('0.025');
 		expect(val4.toPrecision(4)).to.equal('0.025');
 
 		// Case 5
@@ -119,12 +121,22 @@ describe('BigNum Tests', () => {
 		expect(BigNum.fromPrint('1').toMillified(5)).to.equal('1.0000');
 		expect(BigNum.fromPrint('12').toMillified(5)).to.equal('12.000');
 		expect(BigNum.fromPrint('123').toMillified(5)).to.equal('123.00');
-		expect(BigNum.fromPrint('1234').toMillified(5)).to.equal('1.2340K');
-		expect(BigNum.fromPrint('12345').toMillified(5)).to.equal('12.345K');
+		expect(BigNum.fromPrint('1234').toMillified(5)).to.equal('1234.0');
+		expect(BigNum.fromPrint('12345').toMillified(5)).to.equal('12345');
 		expect(BigNum.fromPrint('123456').toMillified(5)).to.equal('123.45K');
 		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', () => {
@@ -133,8 +145,8 @@ describe('BigNum Tests', () => {
 		const baseAmountVal1 = '14.33';
 		const val1 = BigNum.fromPrint(baseAmountVal1, BASE_PRECISION_EXP);
 
-		expect(val1.toString()).to.equal('143300000000000');
-		expect(val1.print()).to.equal('14.3300000000000');
+		expect(val1.toString()).to.equal('14330000000');
+		expect(val1.print()).to.equal('14.330000000');
 
 		const baseAmountVal2 = '34.1';
 		const val2 = BigNum.fromPrint(baseAmountVal2, BASE_PRECISION_EXP);
@@ -216,7 +228,7 @@ describe('BigNum Tests', () => {
 			.shift(AMM_RESERVE_PRECISION_EXP)
 			.div(BigNum.from(entryPriceNum * 10 ** 8));
 
-		expect(val.toString()).to.equal('250000000000');
+		expect(val.toString()).to.equal('25000000');
 		expect(val.printShort()).to.equal('0.025');
 
 		const val2 = BigNum.from(10000, 4);
@@ -251,5 +263,28 @@ describe('BigNum Tests', () => {
 
 		const val9 = BigNum.from('1000000000123', 6);
 		expect(val9.prettyPrint()).to.equal('1,000,000.000123');
+
+		const val10 = BigNum.from('100000000000', 6);
+		expect(val10.prettyPrint(true)).to.equal('100,000');
+	});
+
+	it('can round up and down', () => {
+		const val1 = BigNum.from('1234', 1);
+		expect(val1.toRounded(3).toString()).to.equal('1230');
+
+		const val2 = BigNum.from('1236', 1);
+		expect(val2.toRounded(3).toString()).to.equal('1240');
+
+		const val3 = BigNum.from('123456789', 5);
+		expect(val3.toRounded(4).print()).to.equal('1235.00000');
+
+		const val4 = BigNum.from('123456789', 5);
+		expect(val4.toRounded(3).print()).to.equal('1230.00000');
+
+		const val5 = BigNum.from('123000000', 5);
+		expect(val5.toRounded(3).print()).to.equal('1230.00000');
+
+		const val6 = BigNum.from('0', 5);
+		expect(val6.toRounded(3).print()).to.equal('0.00000');
 	});
 });