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

package/lib/userConfig.d.ts

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

package/lib/userConfig.js

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

package/lib/userMap/userMap.d.ts

@@ -0,0 +1,41 @@
+import { User, DriftClient, OrderRecord, UserSubscriptionConfig } from '..';
+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 declare class UserMap implements UserMapInterface {
+    private userMap;
+    private driftClient;
+    private accountSubscription;
+    constructor(driftClient: DriftClient, accountSubscription: UserSubscriptionConfig);
+    fetchAllUsers(): Promise<void>;
+    addPubkey(userAccountPublicKey: PublicKey): Promise<void>;
+    has(key: string): boolean;
+    /**
+     * 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
+     */
+    get(key: string): User | undefined;
+    /**
+     * gets the User for a particular userAccountPublicKey, if no User exists, new one is created
+     * @param key userAccountPublicKey to get User for
+     * @returns  User
+     */
+    mustGet(key: string): Promise<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
+     */
+    getUserAuthority(key: string): PublicKey | undefined;
+    updateWithOrderRecord(record: OrderRecord): Promise<void>;
+    values(): IterableIterator<User>;
+}

package/lib/userMap/userMap.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserMap = void 0;
+const __1 = require("..");
+const web3_js_1 = require("@solana/web3.js");
+class UserMap {
+    constructor(driftClient, accountSubscription) {
+        this.userMap = new Map();
+        this.driftClient = driftClient;
+        this.accountSubscription = accountSubscription;
+    }
+    async fetchAllUsers() {
+        const userArray = [];
+        const programUserAccounts = (await this.driftClient.program.account.user.all());
+        for (const programUserAccount of programUserAccounts) {
+            if (this.userMap.has(programUserAccount.publicKey.toString())) {
+                continue;
+            }
+            const user = new __1.User({
+                driftClient: this.driftClient,
+                userAccountPublicKey: programUserAccount.publicKey,
+                accountSubscription: this.accountSubscription,
+            });
+            userArray.push(user);
+        }
+        if (this.accountSubscription.type === 'polling') {
+            await (0, __1.bulkPollingUserSubscribe)(userArray, this.accountSubscription.accountLoader);
+        }
+        for (const user of userArray) {
+            this.userMap.set(user.getUserAccountPublicKey().toString(), user);
+        }
+    }
+    async addPubkey(userAccountPublicKey) {
+        const user = new __1.User({
+            driftClient: this.driftClient,
+            userAccountPublicKey,
+            accountSubscription: this.accountSubscription,
+        });
+        await user.subscribe();
+        this.userMap.set(userAccountPublicKey.toString(), user);
+    }
+    has(key) {
+        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
+     */
+    get(key) {
+        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
+     */
+    async mustGet(key) {
+        if (!this.has(key)) {
+            await this.addPubkey(new web3_js_1.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
+     */
+    getUserAuthority(key) {
+        const chUser = this.userMap.get(key);
+        if (!chUser) {
+            return undefined;
+        }
+        return chUser.getUserAccount().authority;
+    }
+    async updateWithOrderRecord(record) {
+        await this.addPubkey(record.user);
+    }
+    values() {
+        return this.userMap.values();
+    }
+}
+exports.UserMap = UserMap;

package/lib/userMap/userStatsMap.d.ts

@@ -0,0 +1,19 @@
+import { DriftClient, OrderRecord, UserStats, UserStatsSubscriptionConfig } from '..';
+import { PublicKey } from '@solana/web3.js';
+import { UserMap } from './userMap';
+export declare class UserStatsMap {
+    /**
+     * map from authority pubkey to UserStats
+     */
+    private userStatsMap;
+    private driftClient;
+    private accountSubscription;
+    constructor(driftClient: DriftClient, accountSubscription: UserStatsSubscriptionConfig);
+    fetchAllUserStats(): Promise<void>;
+    addUserStat(authority: PublicKey): Promise<void>;
+    updateWithOrderRecord(record: OrderRecord, userMap: UserMap): Promise<void>;
+    has(authorityPublicKey: string): boolean;
+    get(authorityPublicKey: string): UserStats;
+    mustGet(authorityPublicKey: string): Promise<UserStats>;
+    values(): IterableIterator<UserStats>;
+}

package/lib/userMap/userStatsMap.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserStatsMap = void 0;
+const __1 = require("..");
+const web3_js_1 = require("@solana/web3.js");
+class UserStatsMap {
+    constructor(driftClient, accountSubscription) {
+        /**
+         * map from authority pubkey to UserStats
+         */
+        this.userStatsMap = new Map();
+        this.driftClient = driftClient;
+        this.accountSubscription = accountSubscription;
+    }
+    async fetchAllUserStats() {
+        const userStatArray = [];
+        const programUserAccounts = (await this.driftClient.program.account.userStats.all());
+        for (const programUserAccount of programUserAccounts) {
+            const userStat = programUserAccount.account;
+            if (this.userStatsMap.has(userStat.authority.toString())) {
+                continue;
+            }
+            const chUserStat = new __1.UserStats({
+                driftClient: this.driftClient,
+                userStatsAccountPublicKey: (0, __1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, userStat.authority),
+                accountSubscription: this.accountSubscription,
+            });
+            userStatArray.push(chUserStat);
+        }
+        if (this.accountSubscription.type === 'polling') {
+            await (0, __1.bulkPollingUserStatsSubscribe)(userStatArray, this.accountSubscription.accountLoader);
+        }
+        for (const userStat of userStatArray) {
+            this.userStatsMap.set(userStat.getAccount().authority.toString(), userStat);
+        }
+    }
+    async addUserStat(authority) {
+        const userStat = new __1.UserStats({
+            driftClient: this.driftClient,
+            userStatsAccountPublicKey: (0, __1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, authority),
+            accountSubscription: this.accountSubscription,
+        });
+        await userStat.subscribe();
+        this.userStatsMap.set(authority.toString(), userStat);
+    }
+    async updateWithOrderRecord(record, userMap) {
+        if (!this.has(record.user.toString())) {
+            const takerUserAccount = await userMap.mustGet(record.user.toString());
+            this.addUserStat(takerUserAccount.getUserAccount().authority);
+        }
+    }
+    has(authorityPublicKey) {
+        return this.userStatsMap.has(authorityPublicKey);
+    }
+    get(authorityPublicKey) {
+        return this.userStatsMap.get(authorityPublicKey);
+    }
+    async mustGet(authorityPublicKey) {
+        if (!this.has(authorityPublicKey)) {
+            await this.addUserStat(new web3_js_1.PublicKey(authorityPublicKey));
+        }
+        return this.get(authorityPublicKey);
+    }
+    values() {
+        return this.userStatsMap.values();
+    }
+}
+exports.UserStatsMap = UserStatsMap;

package/lib/userName.d.ts

@@ -1,4 +1,5 @@
 export declare const MAX_NAME_LENGTH = 32;
 export declare const DEFAULT_USER_NAME = "Main Account";
+export declare const DEFAULT_MARKET_NAME = "Default Market Name";
 export declare function encodeName(name: string): number[];
 export declare function decodeName(bytes: number[]): string;

package/lib/userName.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeName = exports.encodeName = exports.DEFAULT_USER_NAME = exports.MAX_NAME_LENGTH = void 0;
+exports.decodeName = exports.encodeName = exports.DEFAULT_MARKET_NAME = exports.DEFAULT_USER_NAME = exports.MAX_NAME_LENGTH = void 0;
 exports.MAX_NAME_LENGTH = 32;
 exports.DEFAULT_USER_NAME = 'Main Account';
+exports.DEFAULT_MARKET_NAME = 'Default Market Name';
 function encodeName(name) {
     if (name.length > exports.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);
     buffer.fill(name);

package/lib/userStats.d.ts

@@ -0,0 +1,18 @@
+import { DriftClient } from './driftClient';
+import { PublicKey } from '@solana/web3.js';
+import { DataAndSlot, UserStatsAccountSubscriber } from './accounts/types';
+import { UserStatsConfig } from './userStatsConfig';
+import { ReferrerInfo, UserStatsAccount } from './types';
+export declare class UserStats {
+    driftClient: DriftClient;
+    userStatsAccountPublicKey: PublicKey;
+    accountSubscriber: UserStatsAccountSubscriber;
+    isSubscribed: boolean;
+    constructor(config: UserStatsConfig);
+    subscribe(): Promise<boolean>;
+    fetchAccounts(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    getAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+    getAccount(): UserStatsAccount;
+    getReferrerInfo(): ReferrerInfo | undefined;
+}

package/lib/userStats.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserStats = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const pollingUserStatsAccountSubscriber_1 = require("./accounts/pollingUserStatsAccountSubscriber");
+const webSocketUserStatsAccountSubsriber_1 = require("./accounts/webSocketUserStatsAccountSubsriber");
+const pda_1 = require("./addresses/pda");
+class UserStats {
+    constructor(config) {
+        var _a;
+        this.driftClient = config.driftClient;
+        this.userStatsAccountPublicKey = config.userStatsAccountPublicKey;
+        if (((_a = config.accountSubscription) === null || _a === void 0 ? void 0 : _a.type) === 'polling') {
+            this.accountSubscriber = new pollingUserStatsAccountSubscriber_1.PollingUserStatsAccountSubscriber(config.driftClient.program, config.userStatsAccountPublicKey, config.accountSubscription.accountLoader);
+        }
+        else {
+            this.accountSubscriber = new webSocketUserStatsAccountSubsriber_1.WebSocketUserStatsAccountSubscriber(config.driftClient.program, config.userStatsAccountPublicKey);
+        }
+    }
+    async subscribe() {
+        this.isSubscribed = await this.accountSubscriber.subscribe();
+        return this.isSubscribed;
+    }
+    async fetchAccounts() {
+        await this.accountSubscriber.fetch();
+    }
+    async unsubscribe() {
+        await this.accountSubscriber.unsubscribe();
+        this.isSubscribed = false;
+    }
+    getAccountAndSlot() {
+        return this.accountSubscriber.getUserStatsAccountAndSlot();
+    }
+    getAccount() {
+        return this.accountSubscriber.getUserStatsAccountAndSlot().data;
+    }
+    getReferrerInfo() {
+        if (this.getAccount().referrer.equals(web3_js_1.PublicKey.default)) {
+            return undefined;
+        }
+        else {
+            return {
+                referrer: (0, pda_1.getUserAccountPublicKeySync)(this.driftClient.program.programId, this.getAccount().referrer, 0),
+                referrerStats: (0, pda_1.getUserStatsAccountPublicKey)(this.driftClient.program.programId, this.getAccount().referrer),
+            };
+        }
+    }
+}
+exports.UserStats = UserStats;

package/lib/userStatsConfig.d.ts

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

package/lib/userStatsConfig.js

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

package/lib/util/computeUnits.js

@@ -4,7 +4,7 @@ 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`);
+    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]) {

package/lib/util/getTokenAddress.d.ts

@@ -0,0 +1,2 @@
+import { PublicKey } from '@solana/web3.js';
+export declare const getTokenAddress: (mintAddress: string, userPubKey: string) => Promise<PublicKey>;

package/lib/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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.2.0-master.4",
+	"version": "0.2.0-master.40",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -14,7 +14,11 @@
 		"build": "yarn clean && tsc",
 		"clean": "rm -rf lib",
 		"test": "mocha -r ts-node/register tests/**/*.ts",
-		"patch-and-pub": "npm version patch --force && npm publish"
+		"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'"
 	},
 	"keywords": [
 		"drift-labs",
@@ -29,11 +33,13 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@project-serum/anchor": "0.24.2",
+		"@project-serum/anchor": "0.25.0-beta.1",
+		"@project-serum/serum": "^0.13.38",
 		"@pythnetwork/client": "2.5.3",
 		"@solana/spl-token": "^0.1.6",
 		"@solana/web3.js": "1.41.0",
 		"@switchboard-xyz/switchboard-v2": "^0.0.67",
+		"async-mutex": "^0.4.0",
 		"strict-event-emitter-types": "^2.0.0",
 		"uuid": "^8.3.2"
 	},
@@ -48,6 +54,7 @@
 		"eslint-config-prettier": "^8.3.0",
 		"eslint-plugin-prettier": "^3.4.0",
 		"mocha": "^10.0.0",
+		"prettier": "^2.4.1",
 		"ts-node": "^10.8.0"
 	},
 	"description": "SDK for Drift Protocol v1",

package/src/accounts/bulkAccountLoader.ts

@@ -2,6 +2,7 @@ import { Commitment, Connection, PublicKey } from '@solana/web3.js';
 import { v4 as uuidv4 } from 'uuid';
 import { BufferAndSlot } from './types';
 import { promiseTimeout } from '../util/promiseTimeout';
+import { Mutex } from 'async-mutex';
 
 type AccountToLoad = {
 	publicKey: PublicKey;
@@ -22,6 +23,7 @@ export class BulkAccountLoader {
 	intervalId?: NodeJS.Timer;
 	// to handle clients spamming load
 	loadPromise?: Promise<void>;
+	loadPromiseLock: Mutex = new Mutex();
 	loadPromiseResolver: () => void;
 	lastTimeLoadingPromiseCleared = Date.now();
 	mostRecentSlot = 0;
@@ -64,7 +66,9 @@ export class BulkAccountLoader {
 		}
 
 		// if a new account needs to be polled, remove the cached loadPromise in case client calls load immediately after
-		this.loadPromise = undefined;
+		this.loadPromiseLock.runExclusive(() => {
+			this.loadPromise = undefined;
+		});
 
 		return callbackId;
 	}
@@ -101,41 +105,43 @@ export class BulkAccountLoader {
 	}
 
 	public async load(): Promise<void> {
-		if (this.loadPromise) {
-			const now = Date.now();
-			if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
-				this.loadPromise = undefined;
-			} else {
-				return this.loadPromise;
+		await this.loadPromiseLock.runExclusive(async () => {
+			if (this.loadPromise) {
+				const now = Date.now();
+				if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
+					this.loadPromise = undefined;
+				} else {
+					return this.loadPromise;
+				}
 			}
-		}
-
-		this.loadPromise = new Promise((resolver) => {
-			this.loadPromiseResolver = resolver;
-		});
-		this.lastTimeLoadingPromiseCleared = Date.now();
-
-		try {
-			const chunks = this.chunks(
-				Array.from(this.accountsToLoad.values()),
-				GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE
-			);
 
-			await Promise.all(
-				chunks.map((chunk) => {
-					return this.loadChunk(chunk);
-				})
-			);
-		} catch (e) {
-			console.error(`Error in bulkAccountLoader.load()`);
-			console.error(e);
-			for (const [_, callback] of this.errorCallbacks) {
-				callback(e);
+			this.loadPromise = new Promise((resolver) => {
+				this.loadPromiseResolver = resolver;
+			});
+			this.lastTimeLoadingPromiseCleared = Date.now();
+
+			try {
+				const chunks = this.chunks(
+					Array.from(this.accountsToLoad.values()),
+					GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE
+				);
+
+				await Promise.all(
+					chunks.map((chunk) => {
+						return this.loadChunk(chunk);
+					})
+				);
+			} catch (e) {
+				console.error(`Error in bulkAccountLoader.load()`);
+				console.error(e);
+				for (const [_, callback] of this.errorCallbacks) {
+					callback(e);
+				}
+			} finally {
+				this.loadPromiseResolver();
+				this.loadPromise = undefined;
 			}
-		} finally {
-			this.loadPromiseResolver();
-			this.loadPromise = undefined;
-		}
+		});
 	}
 
 	async loadChunk(accountsToLoad: AccountToLoad[]): Promise<void> {
@@ -222,7 +228,11 @@ export class BulkAccountLoader {
 			return;
 		}
 
-		this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
+		if (this.pollingFrequency !== 0)
+			this.intervalId = setInterval(
+				this.load.bind(this),
+				this.pollingFrequency
+			);
 	}
 
 	public stopPolling(): void {

package/src/accounts/bulkUserStatsSubscription.ts

@@ -0,0 +1,33 @@
+import { UserStats } from '../userStats';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { PollingUserStatsAccountSubscriber } from './pollingUserStatsAccountSubscriber';
+
+/**
+ * @param userStats
+ * @param accountLoader
+ */
+export async function bulkPollingUserStatsSubscribe(
+	userStats: UserStats[],
+	accountLoader: BulkAccountLoader
+): Promise<void> {
+	if (userStats.length === 0) {
+		await accountLoader.load();
+		return;
+	}
+
+	await Promise.all(
+		userStats.map((userStat) => {
+			return (
+				userStat.accountSubscriber as PollingUserStatsAccountSubscriber
+			).addToAccountLoader();
+		})
+	);
+
+	await accountLoader.load();
+
+	await Promise.all(
+		userStats.map(async (userStat) => {
+			return userStat.subscribe();
+		})
+	);
+}

package/src/accounts/bulkUserSubscription.ts

@@ -1,4 +1,4 @@
-import { ClearingHouseUser } from '../clearingHouseUser';
+import { User } from '../user';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { PollingUserAccountSubscriber } from './pollingUserAccountSubscriber';
 
@@ -7,7 +7,7 @@ import { PollingUserAccountSubscriber } from './pollingUserAccountSubscriber';
  * @param accountLoader
  */
 export async function bulkPollingUserSubscribe(
-	users: ClearingHouseUser[],
+	users: User[],
 	accountLoader: BulkAccountLoader
 ): Promise<void> {
 	if (users.length === 0) {
@@ -17,7 +17,6 @@ export async function bulkPollingUserSubscribe(
 
 	await Promise.all(
 		users.map((user) => {
-			// Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
 			return (
 				user.accountSubscriber as PollingUserAccountSubscriber
 			).addToAccountLoader();

package/src/accounts/fetch.ts

@@ -1,6 +1,9 @@
 import { Connection, PublicKey } from '@solana/web3.js';
-import { UserAccount } from '../types';
-import { getUserAccountPublicKey } from '../addresses/pda';
+import { UserAccount, UserStatsAccount } from '../types';
+import {
+	getUserAccountPublicKey,
+	getUserStatsAccountPublicKey,
+} from '../addresses/pda';
 import { Program } from '@project-serum/anchor';
 
 export async function fetchUserAccounts(
@@ -31,3 +34,25 @@ export async function fetchUserAccounts(
 		) as UserAccount;
 	});
 }
+
+export async function fetchUserStatsAccount(
+	connection: Connection,
+	program: Program,
+	authority: PublicKey
+): Promise<UserStatsAccount | undefined> {
+	const userStatsPublicKey = getUserStatsAccountPublicKey(
+		program.programId,
+		authority
+	);
+	const accountInfo = await connection.getAccountInfo(
+		userStatsPublicKey,
+		'confirmed'
+	);
+
+	return accountInfo
+		? (program.account.user.coder.accounts.decode(
+				'UserStats',
+				accountInfo.data
+		  ) as UserStatsAccount)
+		: undefined;
+}