@drift-labs/sdk 0.1.36-master.5 → 0.2.0-master.0

package/lib/accounts/bulkAccountLoader.d.ts

@@ -1,31 +1,32 @@
 /// <reference types="node" />
 import { Commitment, Connection, PublicKey } from '@solana/web3.js';
-import { AccountData } from './types';
+import { BufferAndSlot } from './types';
 declare type AccountToLoad = {
     publicKey: PublicKey;
-    callbacks: Map<string, (buffer: Buffer) => void>;
+    callbacks: Map<string, (buffer: Buffer, slot: number) => void>;
 };
 export declare class BulkAccountLoader {
     connection: Connection;
     commitment: Commitment;
     pollingFrequency: number;
     accountsToLoad: Map<string, AccountToLoad>;
-    accountData: Map<string, AccountData>;
+    bufferAndSlotMap: Map<string, BufferAndSlot>;
     errorCallbacks: Map<string, (e: any) => void>;
     intervalId?: NodeJS.Timer;
     loadPromise?: Promise<void>;
     loadPromiseResolver: () => void;
     lastTimeLoadingPromiseCleared: number;
+    mostRecentSlot: number;
     constructor(connection: Connection, commitment: Commitment, pollingFrequency: number);
-    addAccount(publicKey: PublicKey, callback: (buffer: Buffer) => void): string;
+    addAccount(publicKey: PublicKey, callback: (buffer: Buffer, slot: number) => void): string;
     removeAccount(publicKey: PublicKey, callbackId: string): void;
     addErrorCallbacks(callback: (error: Error) => void): string;
     removeErrorCallbacks(callbackId: string): void;
     chunks<T>(array: readonly T[], size: number): T[][];
     load(): Promise<void>;
     loadChunk(accountsToLoad: AccountToLoad[]): Promise<void>;
-    handleAccountCallbacks(accountToLoad: AccountToLoad, buffer: Buffer): void;
-    getAccountData(publicKey: PublicKey): Buffer | undefined;
+    handleAccountCallbacks(accountToLoad: AccountToLoad, buffer: Buffer, slot: number): void;
+    getBufferAndSlot(publicKey: PublicKey): BufferAndSlot | undefined;
     startPolling(): void;
     stopPolling(): void;
     log(msg: string): void;

package/lib/accounts/bulkAccountLoader.js

@@ -1,13 +1,4 @@
 "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.BulkAccountLoader = void 0;
 const uuid_1 = require("uuid");
@@ -17,9 +8,10 @@ const oneMinute = 60 * 1000;
 class BulkAccountLoader {
     constructor(connection, commitment, pollingFrequency) {
         this.accountsToLoad = new Map();
-        this.accountData = new Map();
+        this.bufferAndSlotMap = new Map();
         this.errorCallbacks = new Map();
         this.lastTimeLoadingPromiseCleared = Date.now();
+        this.mostRecentSlot = 0;
         this.connection = connection;
         this.commitment = commitment;
         this.pollingFrequency = pollingFrequency;
@@ -73,100 +65,98 @@ class BulkAccountLoader {
             .map((_, index) => index * size)
             .map((begin) => array.slice(begin, begin + size));
     }
-    load() {
-        return __awaiter(this, void 0, void 0, function* () {
-            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);
-                yield 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();
+    async load() {
+        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);
+            }
+        }
+        finally {
+            this.loadPromiseResolver();
+            this.loadPromise = undefined;
+        }
     }
-    loadChunk(accountsToLoad) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (accountsToLoad.length === 0) {
-                return;
+    async loadChunk(accountsToLoad) {
+        if (accountsToLoad.length === 0) {
+            return;
+        }
+        const args = [
+            accountsToLoad.map((accountToLoad) => {
+                return accountToLoad.publicKey.toBase58();
+            }),
+            { commitment: this.commitment },
+        ];
+        const rpcResponse = await (0, promiseTimeout_1.promiseTimeout)(
+        // @ts-ignore
+        this.connection._rpcRequest('getMultipleAccounts', args), 10 * 1000 // 30 second timeout
+        );
+        if (rpcResponse === null) {
+            this.log('request to rpc timed out');
+            return;
+        }
+        const newSlot = rpcResponse.result.context.slot;
+        if (newSlot > this.mostRecentSlot) {
+            this.mostRecentSlot = newSlot;
+        }
+        for (const i in accountsToLoad) {
+            const accountToLoad = accountsToLoad[i];
+            const key = accountToLoad.publicKey.toString();
+            const oldRPCResponse = this.bufferAndSlotMap.get(key);
+            let newBuffer = undefined;
+            if (rpcResponse.result.value[i]) {
+                const raw = rpcResponse.result.value[i].data[0];
+                const dataType = rpcResponse.result.value[i].data[1];
+                newBuffer = Buffer.from(raw, dataType);
             }
-            const args = [
-                accountsToLoad.map((accountToLoad) => {
-                    return accountToLoad.publicKey.toBase58();
-                }),
-                { commitment: this.commitment },
-            ];
-            const rpcResponse = yield (0, promiseTimeout_1.promiseTimeout)(
-            // @ts-ignore
-            this.connection._rpcRequest('getMultipleAccounts', args), 10 * 1000 // 30 second timeout
-            );
-            if (rpcResponse === null) {
-                this.log('request to rpc timed out');
-                return;
+            if (!oldRPCResponse) {
+                this.bufferAndSlotMap.set(key, {
+                    slot: newSlot,
+                    buffer: newBuffer,
+                });
+                this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+                continue;
             }
-            const newSlot = rpcResponse.result.context.slot;
-            for (const i in accountsToLoad) {
-                const accountToLoad = accountsToLoad[i];
-                const key = accountToLoad.publicKey.toString();
-                const oldRPCResponse = this.accountData.get(key);
-                let newBuffer = undefined;
-                if (rpcResponse.result.value[i]) {
-                    const raw = rpcResponse.result.value[i].data[0];
-                    const dataType = rpcResponse.result.value[i].data[1];
-                    newBuffer = Buffer.from(raw, dataType);
-                }
-                if (!oldRPCResponse) {
-                    this.accountData.set(key, {
-                        slot: newSlot,
-                        buffer: newBuffer,
-                    });
-                    this.handleAccountCallbacks(accountToLoad, newBuffer);
-                    continue;
-                }
-                if (newSlot <= oldRPCResponse.slot) {
-                    continue;
-                }
-                const oldBuffer = oldRPCResponse.buffer;
-                if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
-                    this.accountData.set(key, {
-                        slot: newSlot,
-                        buffer: newBuffer,
-                    });
-                    this.handleAccountCallbacks(accountToLoad, newBuffer);
-                }
+            if (newSlot <= oldRPCResponse.slot) {
+                continue;
             }
-        });
+            const oldBuffer = oldRPCResponse.buffer;
+            if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+                this.bufferAndSlotMap.set(key, {
+                    slot: newSlot,
+                    buffer: newBuffer,
+                });
+                this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
+            }
+        }
     }
-    handleAccountCallbacks(accountToLoad, buffer) {
+    handleAccountCallbacks(accountToLoad, buffer, slot) {
         for (const [_, callback] of accountToLoad.callbacks) {
-            callback(buffer);
+            callback(buffer, slot);
         }
     }
-    getAccountData(publicKey) {
-        const accountData = this.accountData.get(publicKey.toString());
-        return accountData === null || accountData === void 0 ? void 0 : accountData.buffer;
+    getBufferAndSlot(publicKey) {
+        return this.bufferAndSlotMap.get(publicKey.toString());
     }
     startPolling() {
         if (this.intervalId) {

package/lib/accounts/bulkUserSubscription.js

@@ -1,66 +1,22 @@
 "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.bulkPollingUserSubscribe = void 0;
 /**
  * @param users
  * @param accountLoader
  */
-function bulkPollingUserSubscribe(users, accountLoader) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (users.length === 0) {
-            yield accountLoader.load();
-            return;
-        }
-        // Fetch all the accounts first
-        const program = users[0].clearingHouse.program;
-        let userProgramAccounts;
-        let orderProgramAccounts;
-        yield Promise.all([
-            (() => __awaiter(this, void 0, void 0, function* () {
-                userProgramAccounts = yield program.account.user.all();
-            }))(),
-            (() => __awaiter(this, void 0, void 0, function* () {
-                orderProgramAccounts = yield program.account.userOrders.all();
-            }))(),
-        ]);
-        // Create a map of the authority to keys
-        const authorityToKeys = new Map();
-        const userToAuthority = new Map();
-        for (const userProgramAccount of userProgramAccounts) {
-            const userAccountPublicKey = userProgramAccount.publicKey;
-            const userAccount = userProgramAccount.account;
-            authorityToKeys.set(userAccount.authority.toString(), {
-                user: userAccountPublicKey,
-                userPositions: userAccount.positions,
-                userOrders: undefined,
-            });
-            userToAuthority.set(userAccountPublicKey.toString(), userAccount.authority.toString());
-        }
-        for (const orderProgramAccount of orderProgramAccounts) {
-            const userOrderAccountPublicKey = orderProgramAccount.publicKey;
-            const userOrderAccount = orderProgramAccount.account;
-            const authority = userToAuthority.get(userOrderAccount.user.toString());
-            const userPublicKeys = authorityToKeys.get(authority);
-            userPublicKeys.userOrders = userOrderAccountPublicKey;
-        }
-        yield Promise.all(users.map((user) => {
-            // Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
-            const userPublicKeys = authorityToKeys.get(user.authority.toString());
-            return user.accountSubscriber.addToAccountLoader(userPublicKeys);
-        }));
-        yield accountLoader.load();
-        yield Promise.all(users.map((user) => __awaiter(this, void 0, void 0, function* () {
-            return user.subscribe();
-        })));
-    });
+async function bulkPollingUserSubscribe(users, accountLoader) {
+    if (users.length === 0) {
+        await accountLoader.load();
+        return;
+    }
+    await Promise.all(users.map((user) => {
+        // Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
+        return user.accountSubscriber.addToAccountLoader();
+    }));
+    await accountLoader.load();
+    await Promise.all(users.map(async (user) => {
+        return user.subscribe();
+    }));
 }
 exports.bulkPollingUserSubscribe = bulkPollingUserSubscribe;

package/lib/accounts/fetch.d.ts

@@ -0,0 +1,4 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { UserAccount } from '../types';
+import { Program } from '@project-serum/anchor';
+export declare function fetchUserAccounts(connection: Connection, program: Program, authority: PublicKey, limit?: number): Promise<(UserAccount | undefined)[]>;

package/lib/accounts/fetch.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchUserAccounts = void 0;
+const pda_1 = require("../addresses/pda");
+async function fetchUserAccounts(connection, program, authority, limit = 8) {
+    const userAccountPublicKeys = new Array();
+    for (let i = 0; i < limit; i++) {
+        userAccountPublicKeys.push(await (0, pda_1.getUserAccountPublicKey)(program.programId, authority, i));
+    }
+    const accountInfos = await connection.getMultipleAccountsInfo(userAccountPublicKeys, 'confirmed');
+    return accountInfos.map((accountInfo) => {
+        if (!accountInfo) {
+            return undefined;
+        }
+        return program.account.user.coder.accounts.decode('User', accountInfo.data);
+    });
+}
+exports.fetchUserAccounts = fetchUserAccounts;

package/lib/accounts/pollingClearingHouseAccountSubscriber.d.ts

@@ -1,65 +1,61 @@
+/// <reference types="bn.js" />
 /// <reference types="node" />
-import { AccountToPoll, ClearingHouseAccountEvents, ClearingHouseAccountSubscriber, ClearingHouseAccountTypes } from './types';
-import { Program } from '@project-serum/anchor';
+import { DataAndSlot, AccountToPoll, ClearingHouseAccountEvents, ClearingHouseAccountSubscriber, OraclesToPoll } from './types';
+import { BN, Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
-import { DepositHistoryAccount, ExtendedCurveHistoryAccount, FundingPaymentHistoryAccount, FundingRateHistoryAccount, LiquidationHistoryAccount, MarketsAccount, OrderHistoryAccount, OrderStateAccount, StateAccount, TradeHistoryAccount } from '../types';
+import { BankAccount, MarketAccount, StateAccount, UserAccount } from '../types';
 import { BulkAccountLoader } from './bulkAccountLoader';
-import { ClearingHouseConfigType } from '../factory/clearingHouse';
 import { PublicKey } from '@solana/web3.js';
+import { OracleInfo, OraclePriceData } from '../oracles/types';
+import { OracleClientCache } from '../oracles/oracleClientCache';
 export declare class PollingClearingHouseAccountSubscriber implements ClearingHouseAccountSubscriber {
     isSubscribed: boolean;
     program: Program;
+    marketIndexes: BN[];
+    bankIndexes: BN[];
+    oracleInfos: OracleInfo[];
+    oracleClientCache: OracleClientCache;
     eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
     accountLoader: BulkAccountLoader;
     accountsToPoll: Map<string, AccountToPoll>;
+    oraclesToPoll: Map<string, OraclesToPoll>;
     errorCallbackId?: string;
-    state?: StateAccount;
-    markets?: MarketsAccount;
-    orderState?: OrderStateAccount;
-    tradeHistory?: TradeHistoryAccount;
-    depositHistory?: DepositHistoryAccount;
-    fundingPaymentHistory?: FundingPaymentHistoryAccount;
-    fundingRateHistory?: FundingRateHistoryAccount;
-    liquidationHistory?: LiquidationHistoryAccount;
-    extendedCurveHistory: ExtendedCurveHistoryAccount;
-    orderHistory?: OrderHistoryAccount;
-    optionalExtraSubscriptions: ClearingHouseAccountTypes[];
-    type: ClearingHouseConfigType;
+    state?: DataAndSlot<StateAccount>;
+    market: Map<number, DataAndSlot<MarketAccount>>;
+    bank: Map<number, DataAndSlot<BankAccount>>;
+    oracles: Map<string, DataAndSlot<OraclePriceData>>;
+    user?: DataAndSlot<UserAccount>;
     private isSubscribing;
     private subscriptionPromise;
     private subscriptionPromiseResolver;
-    constructor(program: Program, accountLoader: BulkAccountLoader);
-    subscribe(optionalSubscriptions?: ClearingHouseAccountTypes[]): Promise<boolean>;
+    constructor(program: Program, accountLoader: BulkAccountLoader, marketIndexes: BN[], bankIndexes: BN[], oracleInfos: OracleInfo[]);
+    subscribe(): Promise<boolean>;
     updateAccountsToPoll(): Promise<void>;
+    updateMarketAccountsToPoll(): Promise<boolean>;
+    addMarketAccountToPoll(marketIndex: BN): Promise<boolean>;
+    updateBankAccountsToPoll(): Promise<boolean>;
+    addBankAccountToPoll(bankIndex: BN): Promise<boolean>;
+    updateOraclesToPoll(): boolean;
+    addOracleToPoll(oracleInfo: OracleInfo): boolean;
     getClearingHouseAccounts(): Promise<ClearingHouseAccounts>;
     addToAccountLoader(): Promise<void>;
+    addAccountToAccountLoader(accountToPoll: AccountToPoll): void;
+    addOracleToAccountLoader(oracleToPoll: OraclesToPoll): void;
     fetch(): Promise<void>;
     didSubscriptionSucceed(): boolean;
     unsubscribe(): Promise<void>;
+    addBank(bankIndex: BN): Promise<boolean>;
+    addMarket(marketIndex: BN): Promise<boolean>;
+    addOracle(oracleInfo: OracleInfo): Promise<boolean>;
     assertIsSubscribed(): void;
-    assertOptionalIsSubscribed(optionalSubscription: ClearingHouseAccountTypes): void;
-    getStateAccount(): StateAccount;
-    getMarketsAccount(): MarketsAccount;
-    getOrderStateAccount(): OrderStateAccount;
-    getTradeHistoryAccount(): TradeHistoryAccount;
-    getDepositHistoryAccount(): DepositHistoryAccount;
-    getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
-    getFundingRateHistoryAccount(): FundingRateHistoryAccount;
-    getCurveHistoryAccount(): ExtendedCurveHistoryAccount;
-    getLiquidationHistoryAccount(): LiquidationHistoryAccount;
-    getOrderHistoryAccount(): OrderHistoryAccount;
+    getStateAccountAndSlot(): DataAndSlot<StateAccount>;
+    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<MarketAccount> | undefined;
+    getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[];
+    getBankAccountAndSlot(bankIndex: BN): DataAndSlot<BankAccount> | undefined;
+    getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
 }
 declare type ClearingHouseAccounts = {
     state: PublicKey;
-    markets: PublicKey;
-    orderState: PublicKey;
-    tradeHistory?: PublicKey;
-    depositHistory?: PublicKey;
-    fundingPaymentHistory?: PublicKey;
-    fundingRateHistory?: PublicKey;
-    extendedCurveHistory?: PublicKey;
-    liquidationHistory?: PublicKey;
-    orderHistory?: PublicKey;
 };
 export {};