@drift-labs/sdk 0.2.0-master.24 → 0.2.0-master.26

package/lib/accounts/pollingClearingHouseAccountSubscriber.d.ts

@@ -4,7 +4,7 @@ import { DataAndSlot, AccountToPoll, ClearingHouseAccountEvents, ClearingHouseAc
 import { BN, Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
-import { BankAccount, MarketAccount, StateAccount, UserAccount } from '../types';
+import { SpotMarketAccount, PerpMarketAccount, StateAccount, UserAccount } from '../types';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { PublicKey } from '@solana/web3.js';
 import { OracleInfo, OraclePriceData } from '../oracles/types';
@@ -12,8 +12,8 @@ import { OracleClientCache } from '../oracles/oracleClientCache';
 export declare class PollingClearingHouseAccountSubscriber implements ClearingHouseAccountSubscriber {
     isSubscribed: boolean;
     program: Program;
-    marketIndexes: BN[];
-    bankIndexes: BN[];
+    perpMarketIndexes: BN[];
+    spotMarketIndexes: BN[];
     oracleInfos: OracleInfo[];
     oracleClientCache: OracleClientCache;
     eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
@@ -22,20 +22,20 @@ export declare class PollingClearingHouseAccountSubscriber implements ClearingHo
     oraclesToPoll: Map<string, OraclesToPoll>;
     errorCallbackId?: string;
     state?: DataAndSlot<StateAccount>;
-    market: Map<number, DataAndSlot<MarketAccount>>;
-    bank: Map<number, DataAndSlot<BankAccount>>;
+    perpMarket: Map<number, DataAndSlot<PerpMarketAccount>>;
+    spotMarket: Map<number, DataAndSlot<SpotMarketAccount>>;
     oracles: Map<string, DataAndSlot<OraclePriceData>>;
     user?: DataAndSlot<UserAccount>;
     private isSubscribing;
     private subscriptionPromise;
     private subscriptionPromiseResolver;
-    constructor(program: Program, accountLoader: BulkAccountLoader, marketIndexes: BN[], bankIndexes: BN[], oracleInfos: OracleInfo[]);
+    constructor(program: Program, accountLoader: BulkAccountLoader, perpMarketIndexes: BN[], spotMarketIndexes: 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>;
+    updateSpotMarketAccountsToPoll(): Promise<boolean>;
+    addSpotMarketAccountToPoll(marketIndex: BN): Promise<boolean>;
     updateOraclesToPoll(): boolean;
     addOracleToPoll(oracleInfo: OracleInfo): boolean;
     getClearingHouseAccounts(): Promise<ClearingHouseAccounts>;
@@ -45,14 +45,14 @@ export declare class PollingClearingHouseAccountSubscriber implements ClearingHo
     fetch(): Promise<void>;
     didSubscriptionSucceed(): boolean;
     unsubscribe(): Promise<void>;
-    addBank(bankIndex: BN): Promise<boolean>;
-    addMarket(marketIndex: BN): Promise<boolean>;
+    addSpotMarket(marketIndex: BN): Promise<boolean>;
+    addPerpMarket(marketIndex: BN): Promise<boolean>;
     addOracle(oracleInfo: OracleInfo): Promise<boolean>;
     assertIsSubscribed(): void;
     getStateAccountAndSlot(): DataAndSlot<StateAccount>;
-    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<MarketAccount> | undefined;
-    getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[];
-    getBankAccountAndSlot(bankIndex: BN): DataAndSlot<BankAccount> | undefined;
+    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<PerpMarketAccount> | undefined;
+    getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[];
+    getSpotMarketAccountAndSlot(marketIndex: BN): DataAndSlot<SpotMarketAccount> | undefined;
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
 }
 declare type ClearingHouseAccounts = {

package/lib/accounts/pollingClearingHouseAccountSubscriber.js

@@ -9,20 +9,20 @@ const web3_js_1 = require("@solana/web3.js");
 const oracleClientCache_1 = require("../oracles/oracleClientCache");
 const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
 class PollingClearingHouseAccountSubscriber {
-    constructor(program, accountLoader, marketIndexes, bankIndexes, oracleInfos) {
+    constructor(program, accountLoader, perpMarketIndexes, spotMarketIndexes, oracleInfos) {
         this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
         this.accountsToPoll = new Map();
         this.oraclesToPoll = new Map();
-        this.market = new Map();
-        this.bank = new Map();
+        this.perpMarket = new Map();
+        this.spotMarket = new Map();
         this.oracles = new Map();
         this.isSubscribing = false;
         this.isSubscribed = false;
         this.program = program;
         this.eventEmitter = new events_1.EventEmitter();
         this.accountLoader = accountLoader;
-        this.marketIndexes = marketIndexes;
-        this.bankIndexes = bankIndexes;
+        this.perpMarketIndexes = perpMarketIndexes;
+        this.spotMarketIndexes = spotMarketIndexes;
         this.oracleInfos = oracleInfos;
     }
     async subscribe() {
@@ -65,10 +65,10 @@ class PollingClearingHouseAccountSubscriber {
             eventType: 'stateAccountUpdate',
         });
         await this.updateMarketAccountsToPoll();
-        await this.updateBankAccountsToPoll();
+        await this.updateSpotMarketAccountsToPoll();
     }
     async updateMarketAccountsToPoll() {
-        for (const marketIndex of this.marketIndexes) {
+        for (const marketIndex of this.perpMarketIndexes) {
             await this.addMarketAccountToPoll(marketIndex);
         }
         return true;
@@ -76,26 +76,26 @@ class PollingClearingHouseAccountSubscriber {
     async addMarketAccountToPoll(marketIndex) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
         this.accountsToPoll.set(marketPublicKey.toString(), {
-            key: 'market',
+            key: 'perpMarket',
             publicKey: marketPublicKey,
-            eventType: 'marketAccountUpdate',
+            eventType: 'perpMarketAccountUpdate',
             mapKey: marketIndex.toNumber(),
         });
         return true;
     }
-    async updateBankAccountsToPoll() {
-        for (const bankIndex of this.bankIndexes) {
-            await this.addBankAccountToPoll(bankIndex);
+    async updateSpotMarketAccountsToPoll() {
+        for (const marketIndex of this.spotMarketIndexes) {
+            await this.addSpotMarketAccountToPoll(marketIndex);
         }
         return true;
     }
-    async addBankAccountToPoll(bankIndex) {
-        const bankPublicKey = await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex);
-        this.accountsToPoll.set(bankPublicKey.toString(), {
-            key: 'bank',
-            publicKey: bankPublicKey,
-            eventType: 'bankAccountUpdate',
-            mapKey: bankIndex.toNumber(),
+    async addSpotMarketAccountToPoll(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex);
+        this.accountsToPoll.set(marketPublicKey.toString(), {
+            key: 'spotMarket',
+            publicKey: marketPublicKey,
+            eventType: 'spotMarketAccountUpdate',
+            mapKey: marketIndex.toNumber(),
         });
         return true;
     }
@@ -223,13 +223,13 @@ class PollingClearingHouseAccountSubscriber {
         this.oraclesToPoll.clear();
         this.isSubscribed = false;
     }
-    async addBank(bankIndex) {
-        await this.addBankAccountToPoll(bankIndex);
-        const accountToPoll = this.accountsToPoll.get(bankIndex.toString());
+    async addSpotMarket(marketIndex) {
+        await this.addSpotMarketAccountToPoll(marketIndex);
+        const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
         this.addAccountToAccountLoader(accountToPoll);
         return true;
     }
-    async addMarket(marketIndex) {
+    async addPerpMarket(marketIndex) {
         await this.addMarketAccountToPoll(marketIndex);
         const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
         this.addAccountToAccountLoader(accountToPoll);
@@ -254,13 +254,13 @@ class PollingClearingHouseAccountSubscriber {
         return this.state;
     }
     getMarketAccountAndSlot(marketIndex) {
-        return this.market.get(marketIndex.toNumber());
+        return this.perpMarket.get(marketIndex.toNumber());
     }
     getMarketAccountsAndSlots() {
-        return Array.from(this.market.values());
+        return Array.from(this.perpMarket.values());
     }
-    getBankAccountAndSlot(bankIndex) {
-        return this.bank.get(bankIndex.toNumber());
+    getSpotMarketAccountAndSlot(marketIndex) {
+        return this.spotMarket.get(marketIndex.toNumber());
     }
     getOraclePriceDataAndSlot(oraclePublicKey) {
         this.assertIsSubscribed();

package/lib/accounts/types.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
 /// <reference types="bn.js" />
-/// <reference types="node" />
-import { BankAccount, MarketAccount, OracleSource, StateAccount, UserAccount, UserStatsAccount } from '../types';
+import { SpotMarketAccount, PerpMarketAccount, OracleSource, StateAccount, UserAccount, UserStatsAccount } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
@@ -19,8 +18,8 @@ export declare class NotSubscribedError extends Error {
 }
 export interface ClearingHouseAccountEvents {
     stateAccountUpdate: (payload: StateAccount) => void;
-    marketAccountUpdate: (payload: MarketAccount) => void;
-    bankAccountUpdate: (payload: BankAccount) => void;
+    perpMarketAccountUpdate: (payload: PerpMarketAccount) => void;
+    spotMarketAccountUpdate: (payload: SpotMarketAccount) => void;
     oraclePriceUpdate: (publicKey: PublicKey, data: OraclePriceData) => void;
     userAccountUpdate: (payload: UserAccount) => void;
     update: void;
@@ -32,13 +31,13 @@ export interface ClearingHouseAccountSubscriber {
     subscribe(): Promise<boolean>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
-    addMarket(marketIndex: BN): Promise<boolean>;
-    addBank(bankIndex: BN): Promise<boolean>;
+    addPerpMarket(marketIndex: BN): Promise<boolean>;
+    addSpotMarket(marketIndex: BN): Promise<boolean>;
     addOracle(oracleInfo: OracleInfo): Promise<boolean>;
     getStateAccountAndSlot(): DataAndSlot<StateAccount>;
-    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<MarketAccount> | undefined;
-    getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[];
-    getBankAccountAndSlot(bankIndex: BN): DataAndSlot<BankAccount> | undefined;
+    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<PerpMarketAccount> | undefined;
+    getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[];
+    getSpotMarketAccountAndSlot(marketIndex: BN): DataAndSlot<SpotMarketAccount> | undefined;
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
 }
 export interface UserAccountEvents {

package/lib/accounts/webSocketClearingHouseAccountSubscriber.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 import { ClearingHouseAccountSubscriber, ClearingHouseAccountEvents, DataAndSlot } from './types';
 import { AccountSubscriber } from './types';
-import { BankAccount, MarketAccount, StateAccount } from '../types';
+import { SpotMarketAccount, PerpMarketAccount, StateAccount } from '../types';
 import { BN, Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
@@ -12,38 +12,38 @@ import { OracleClientCache } from '../oracles/oracleClientCache';
 export declare class WebSocketClearingHouseAccountSubscriber implements ClearingHouseAccountSubscriber {
     isSubscribed: boolean;
     program: Program;
-    marketIndexes: BN[];
-    bankIndexes: BN[];
+    perpMarketIndexes: BN[];
+    spotMarketIndexes: BN[];
     oracleInfos: OracleInfo[];
     oracleClientCache: OracleClientCache;
     eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
     stateAccountSubscriber?: AccountSubscriber<StateAccount>;
-    marketAccountSubscribers: Map<number, AccountSubscriber<MarketAccount>>;
-    bankAccountSubscribers: Map<number, AccountSubscriber<BankAccount>>;
+    perpMarketAccountSubscribers: Map<number, AccountSubscriber<PerpMarketAccount>>;
+    spotMarketAccountSubscribers: Map<number, AccountSubscriber<SpotMarketAccount>>;
     oracleSubscribers: Map<string, AccountSubscriber<OraclePriceData>>;
     private isSubscribing;
     private subscriptionPromise;
     private subscriptionPromiseResolver;
-    constructor(program: Program, marketIndexes: BN[], bankIndexes: BN[], oracleInfos: OracleInfo[]);
+    constructor(program: Program, perpMarketIndexes: BN[], spotMarketIndexes: BN[], oracleInfos: OracleInfo[]);
     subscribe(): Promise<boolean>;
     subscribeToMarketAccounts(): Promise<boolean>;
     subscribeToMarketAccount(marketIndex: BN): Promise<boolean>;
-    subscribeToBankAccounts(): Promise<boolean>;
-    subscribeToBankAccount(bankIndex: BN): Promise<boolean>;
+    subscribeToSpotMarketAccounts(): Promise<boolean>;
+    subscribeToSpotMarketAccount(marketIndex: BN): Promise<boolean>;
     subscribeToOracles(): Promise<boolean>;
     subscribeToOracle(oracleInfo: OracleInfo): Promise<boolean>;
     unsubscribeFromMarketAccounts(): Promise<void>;
-    unsubscribeFromBankAccounts(): Promise<void>;
+    unsubscribeFromSpotMarketAccounts(): Promise<void>;
     unsubscribeFromOracles(): Promise<void>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
-    addBank(bankIndex: BN): Promise<boolean>;
-    addMarket(marketIndex: BN): Promise<boolean>;
+    addSpotMarket(marketIndex: BN): Promise<boolean>;
+    addPerpMarket(marketIndex: BN): Promise<boolean>;
     addOracle(oracleInfo: OracleInfo): Promise<boolean>;
     assertIsSubscribed(): void;
     getStateAccountAndSlot(): DataAndSlot<StateAccount>;
-    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<MarketAccount> | undefined;
-    getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[];
-    getBankAccountAndSlot(bankIndex: BN): DataAndSlot<BankAccount> | undefined;
+    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<PerpMarketAccount> | undefined;
+    getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[];
+    getSpotMarketAccountAndSlot(marketIndex: BN): DataAndSlot<SpotMarketAccount> | undefined;
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
 }

package/lib/accounts/webSocketClearingHouseAccountSubscriber.js

@@ -9,17 +9,17 @@ const web3_js_1 = require("@solana/web3.js");
 const oracleClientCache_1 = require("../oracles/oracleClientCache");
 const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
 class WebSocketClearingHouseAccountSubscriber {
-    constructor(program, marketIndexes, bankIndexes, oracleInfos) {
+    constructor(program, perpMarketIndexes, spotMarketIndexes, oracleInfos) {
         this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
-        this.marketAccountSubscribers = new Map();
-        this.bankAccountSubscribers = new Map();
+        this.perpMarketAccountSubscribers = new Map();
+        this.spotMarketAccountSubscribers = new Map();
         this.oracleSubscribers = new Map();
         this.isSubscribing = false;
         this.isSubscribed = false;
         this.program = program;
         this.eventEmitter = new events_1.EventEmitter();
-        this.marketIndexes = marketIndexes;
-        this.bankIndexes = bankIndexes;
+        this.perpMarketIndexes = perpMarketIndexes;
+        this.spotMarketIndexes = spotMarketIndexes;
         this.oracleInfos = oracleInfos;
     }
     async subscribe() {
@@ -42,8 +42,8 @@ class WebSocketClearingHouseAccountSubscriber {
         });
         // subscribe to market accounts
         await this.subscribeToMarketAccounts();
-        // subscribe to bank accounts
-        await this.subscribeToBankAccounts();
+        // subscribe to spot market accounts
+        await this.subscribeToSpotMarketAccounts();
         // subscribe to oracles
         await this.subscribeToOracles();
         this.eventEmitter.emit('update');
@@ -53,35 +53,35 @@ class WebSocketClearingHouseAccountSubscriber {
         return true;
     }
     async subscribeToMarketAccounts() {
-        for (const marketIndex of this.marketIndexes) {
+        for (const marketIndex of this.perpMarketIndexes) {
             await this.subscribeToMarketAccount(marketIndex);
         }
         return true;
     }
     async subscribeToMarketAccount(marketIndex) {
         const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('market', this.program, marketPublicKey);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('perpMarket', this.program, marketPublicKey);
         await accountSubscriber.subscribe((data) => {
-            this.eventEmitter.emit('marketAccountUpdate', data);
+            this.eventEmitter.emit('perpMarketAccountUpdate', data);
             this.eventEmitter.emit('update');
         });
-        this.marketAccountSubscribers.set(marketIndex.toNumber(), accountSubscriber);
+        this.perpMarketAccountSubscribers.set(marketIndex.toNumber(), accountSubscriber);
         return true;
     }
-    async subscribeToBankAccounts() {
-        for (const bankIndex of this.bankIndexes) {
-            await this.subscribeToBankAccount(bankIndex);
+    async subscribeToSpotMarketAccounts() {
+        for (const marketIndex of this.spotMarketIndexes) {
+            await this.subscribeToSpotMarketAccount(marketIndex);
         }
         return true;
     }
-    async subscribeToBankAccount(bankIndex) {
-        const bankPublicKey = await (0, pda_1.getBankPublicKey)(this.program.programId, bankIndex);
-        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('bank', this.program, bankPublicKey);
+    async subscribeToSpotMarketAccount(marketIndex) {
+        const marketPublicKey = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex);
+        const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('spotMarket', this.program, marketPublicKey);
         await accountSubscriber.subscribe((data) => {
-            this.eventEmitter.emit('bankAccountUpdate', data);
+            this.eventEmitter.emit('spotMarketAccountUpdate', data);
             this.eventEmitter.emit('update');
         });
-        this.bankAccountSubscribers.set(bankIndex.toNumber(), accountSubscriber);
+        this.spotMarketAccountSubscribers.set(marketIndex.toNumber(), accountSubscriber);
         return true;
     }
     async subscribeToOracles() {
@@ -105,12 +105,12 @@ class WebSocketClearingHouseAccountSubscriber {
         return true;
     }
     async unsubscribeFromMarketAccounts() {
-        for (const accountSubscriber of this.marketAccountSubscribers.values()) {
+        for (const accountSubscriber of this.perpMarketAccountSubscribers.values()) {
             await accountSubscriber.unsubscribe();
         }
     }
-    async unsubscribeFromBankAccounts() {
-        for (const accountSubscriber of this.bankAccountSubscribers.values()) {
+    async unsubscribeFromSpotMarketAccounts() {
+        for (const accountSubscriber of this.spotMarketAccountSubscribers.values()) {
             await accountSubscriber.unsubscribe();
         }
     }
@@ -124,8 +124,8 @@ class WebSocketClearingHouseAccountSubscriber {
             return;
         }
         const promises = [this.stateAccountSubscriber.fetch()]
-            .concat(Array.from(this.marketAccountSubscribers.values()).map((subscriber) => subscriber.fetch()))
-            .concat(Array.from(this.bankAccountSubscribers.values()).map((subscriber) => subscriber.fetch()));
+            .concat(Array.from(this.perpMarketAccountSubscribers.values()).map((subscriber) => subscriber.fetch()))
+            .concat(Array.from(this.spotMarketAccountSubscribers.values()).map((subscriber) => subscriber.fetch()));
         await Promise.all(promises);
     }
     async unsubscribe() {
@@ -134,18 +134,18 @@ class WebSocketClearingHouseAccountSubscriber {
         }
         await this.stateAccountSubscriber.unsubscribe();
         await this.unsubscribeFromMarketAccounts();
-        await this.unsubscribeFromBankAccounts();
+        await this.unsubscribeFromSpotMarketAccounts();
         await this.unsubscribeFromOracles();
         this.isSubscribed = false;
     }
-    async addBank(bankIndex) {
-        if (this.bankAccountSubscribers.has(bankIndex.toNumber())) {
+    async addSpotMarket(marketIndex) {
+        if (this.spotMarketAccountSubscribers.has(marketIndex.toNumber())) {
             return true;
         }
-        return this.subscribeToBankAccount(bankIndex);
+        return this.subscribeToSpotMarketAccount(marketIndex);
     }
-    async addMarket(marketIndex) {
-        if (this.marketAccountSubscribers.has(marketIndex.toNumber())) {
+    async addPerpMarket(marketIndex) {
+        if (this.perpMarketAccountSubscribers.has(marketIndex.toNumber())) {
             return true;
         }
         return this.subscribeToMarketAccount(marketIndex);
@@ -170,15 +170,16 @@ class WebSocketClearingHouseAccountSubscriber {
     }
     getMarketAccountAndSlot(marketIndex) {
         this.assertIsSubscribed();
-        return this.marketAccountSubscribers.get(marketIndex.toNumber())
+        return this.perpMarketAccountSubscribers.get(marketIndex.toNumber())
             .dataAndSlot;
     }
     getMarketAccountsAndSlots() {
-        return Array.from(this.marketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
+        return Array.from(this.perpMarketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
     }
-    getBankAccountAndSlot(bankIndex) {
+    getSpotMarketAccountAndSlot(marketIndex) {
         this.assertIsSubscribed();
-        return this.bankAccountSubscribers.get(bankIndex.toNumber()).dataAndSlot;
+        return this.spotMarketAccountSubscribers.get(marketIndex.toNumber())
+            .dataAndSlot;
     }
     getOraclePriceDataAndSlot(oraclePublicKey) {
         this.assertIsSubscribed();

package/lib/addresses/pda.d.ts

@@ -8,9 +8,11 @@ export declare function getUserAccountPublicKey(programId: PublicKey, authority:
 export declare function getUserAccountPublicKeySync(programId: PublicKey, authority: PublicKey, userId?: number): PublicKey;
 export declare function getUserStatsAccountPublicKey(programId: PublicKey, authority: PublicKey): PublicKey;
 export declare function getMarketPublicKey(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
-export declare function getBankPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
-export declare function getBankVaultPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
-export declare function getBankVaultAuthorityPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
-export declare function getInsuranceFundVaultPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
-export declare function getInsuranceFundVaultAuthorityPublicKey(programId: PublicKey, bankIndex: BN): Promise<PublicKey>;
-export declare function getInsuranceFundStakeAccountPublicKey(programId: PublicKey, authority: PublicKey, bankIndex: BN): PublicKey;
+export declare function getSpotMarketPublicKey(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
+export declare function getSpotMarketVaultPublicKey(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
+export declare function getInsuranceFundVaultPublicKey(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
+export declare function getInsuranceFundStakeAccountPublicKey(programId: PublicKey, authority: PublicKey, marketIndex: BN): PublicKey;
+export declare function getClearingHouseSignerPublicKey(programId: PublicKey): PublicKey;
+export declare function getSerumOpenOrdersPublicKey(programId: PublicKey, market: PublicKey): PublicKey;
+export declare function getSerumSignerPublicKey(programId: PublicKey, market: PublicKey, nonce: BN): PublicKey;
+export declare function getSerumFulfillmentConfigPublicKey(programId: PublicKey, market: PublicKey): PublicKey;

package/lib/addresses/pda.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getInsuranceFundStakeAccountPublicKey = exports.getInsuranceFundVaultAuthorityPublicKey = exports.getInsuranceFundVaultPublicKey = exports.getBankVaultAuthorityPublicKey = exports.getBankVaultPublicKey = exports.getBankPublicKey = exports.getMarketPublicKey = exports.getUserStatsAccountPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getClearingHouseStateAccountPublicKey = exports.getClearingHouseStateAccountPublicKeyAndNonce = void 0;
+exports.getSerumFulfillmentConfigPublicKey = exports.getSerumSignerPublicKey = exports.getSerumOpenOrdersPublicKey = exports.getClearingHouseSignerPublicKey = exports.getInsuranceFundStakeAccountPublicKey = exports.getInsuranceFundVaultPublicKey = exports.getSpotMarketVaultPublicKey = exports.getSpotMarketPublicKey = exports.getMarketPublicKey = exports.getUserStatsAccountPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getClearingHouseStateAccountPublicKey = exports.getClearingHouseStateAccountPublicKeyAndNonce = void 0;
 const anchor = __importStar(require("@project-serum/anchor"));
 async function getClearingHouseStateAccountPublicKeyAndNonce(programId) {
     return anchor.web3.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('clearing_house'))], programId);
@@ -67,46 +67,54 @@ async function getMarketPublicKey(programId, marketIndex) {
     ], programId))[0];
 }
 exports.getMarketPublicKey = getMarketPublicKey;
-async function getBankPublicKey(programId, bankIndex) {
+async function getSpotMarketPublicKey(programId, marketIndex) {
     return (await anchor.web3.PublicKey.findProgramAddress([
-        Buffer.from(anchor.utils.bytes.utf8.encode('bank')),
-        bankIndex.toArrayLike(Buffer, 'le', 8),
-    ], programId))[0];
-}
-exports.getBankPublicKey = getBankPublicKey;
-async function getBankVaultPublicKey(programId, bankIndex) {
-    return (await anchor.web3.PublicKey.findProgramAddress([
-        Buffer.from(anchor.utils.bytes.utf8.encode('bank_vault')),
-        bankIndex.toArrayLike(Buffer, 'le', 8),
+        Buffer.from(anchor.utils.bytes.utf8.encode('spot_market')),
+        marketIndex.toArrayLike(Buffer, 'le', 8),
     ], programId))[0];
 }
-exports.getBankVaultPublicKey = getBankVaultPublicKey;
-async function getBankVaultAuthorityPublicKey(programId, bankIndex) {
+exports.getSpotMarketPublicKey = getSpotMarketPublicKey;
+async function getSpotMarketVaultPublicKey(programId, marketIndex) {
     return (await anchor.web3.PublicKey.findProgramAddress([
-        Buffer.from(anchor.utils.bytes.utf8.encode('bank_vault_authority')),
-        bankIndex.toArrayLike(Buffer, 'le', 8),
+        Buffer.from(anchor.utils.bytes.utf8.encode('spot_market_vault')),
+        marketIndex.toArrayLike(Buffer, 'le', 8),
     ], programId))[0];
 }
-exports.getBankVaultAuthorityPublicKey = getBankVaultAuthorityPublicKey;
-async function getInsuranceFundVaultPublicKey(programId, bankIndex) {
+exports.getSpotMarketVaultPublicKey = getSpotMarketVaultPublicKey;
+async function getInsuranceFundVaultPublicKey(programId, marketIndex) {
     return (await anchor.web3.PublicKey.findProgramAddress([
         Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_vault')),
-        bankIndex.toArrayLike(Buffer, 'le', 8),
+        marketIndex.toArrayLike(Buffer, 'le', 8),
     ], programId))[0];
 }
 exports.getInsuranceFundVaultPublicKey = getInsuranceFundVaultPublicKey;
-async function getInsuranceFundVaultAuthorityPublicKey(programId, bankIndex) {
-    return (await anchor.web3.PublicKey.findProgramAddress([
-        Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_vault_authority')),
-        bankIndex.toArrayLike(Buffer, 'le', 8),
-    ], programId))[0];
-}
-exports.getInsuranceFundVaultAuthorityPublicKey = getInsuranceFundVaultAuthorityPublicKey;
-function getInsuranceFundStakeAccountPublicKey(programId, authority, bankIndex) {
+function getInsuranceFundStakeAccountPublicKey(programId, authority, marketIndex) {
     return anchor.web3.PublicKey.findProgramAddressSync([
         Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_stake')),
         authority.toBuffer(),
-        bankIndex.toArrayLike(Buffer, 'le', 8),
+        marketIndex.toArrayLike(Buffer, 'le', 8),
     ], programId)[0];
 }
 exports.getInsuranceFundStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey;
+function getClearingHouseSignerPublicKey(programId) {
+    return anchor.web3.PublicKey.findProgramAddressSync([Buffer.from(anchor.utils.bytes.utf8.encode('clearing_house_signer'))], programId)[0];
+}
+exports.getClearingHouseSignerPublicKey = getClearingHouseSignerPublicKey;
+function getSerumOpenOrdersPublicKey(programId, market) {
+    return anchor.web3.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('serum_open_orders')),
+        market.toBuffer(),
+    ], programId)[0];
+}
+exports.getSerumOpenOrdersPublicKey = getSerumOpenOrdersPublicKey;
+function getSerumSignerPublicKey(programId, market, nonce) {
+    return anchor.web3.PublicKey.createProgramAddressSync([market.toBuffer(), nonce.toArrayLike(Buffer, 'le', 8)], programId);
+}
+exports.getSerumSignerPublicKey = getSerumSignerPublicKey;
+function getSerumFulfillmentConfigPublicKey(programId, market) {
+    return anchor.web3.PublicKey.findProgramAddressSync([
+        Buffer.from(anchor.utils.bytes.utf8.encode('serum_fulfillment_config')),
+        market.toBuffer(),
+    ], programId)[0];
+}
+exports.getSerumFulfillmentConfigPublicKey = getSerumFulfillmentConfigPublicKey;

package/lib/admin.d.ts

@@ -5,11 +5,12 @@ import { BN } from '@project-serum/anchor';
 import { ClearingHouse } from './clearingHouse';
 export declare class Admin extends ClearingHouse {
     initialize(usdcMint: PublicKey, adminControlsPrices: boolean): Promise<[TransactionSignature]>;
-    initializeBank(mint: PublicKey, optimalUtilization: BN, optimalRate: BN, maxRate: BN, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN, liquidationFee?: BN): Promise<TransactionSignature>;
+    initializeSpotMarket(mint: PublicKey, optimalUtilization: BN, optimalRate: BN, maxRate: BN, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN, liquidationFee?: BN): Promise<TransactionSignature>;
+    initializeSerumFulfillmentConfig(marketIndex: BN, serumMarket: PublicKey, serumProgram: PublicKey): Promise<TransactionSignature>;
     initializeMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioMaintenance?: number, liquidationFee?: BN): Promise<TransactionSignature>;
-    moveAmmPrice(baseAssetReserve: BN, quoteAssetReserve: BN, marketIndex: BN): Promise<TransactionSignature>;
+    moveAmmPrice(marketIndex: BN, baseAssetReserve: BN, quoteAssetReserve: BN, sqrtK?: BN): Promise<TransactionSignature>;
     updateK(sqrtK: BN, marketIndex: BN): Promise<TransactionSignature>;
-    moveAmmToPrice(marketIndex: BN, targetPrice: BN): Promise<TransactionSignature>;
+    moveAmmToPrice(perpMarketIndex: BN, targetPrice: BN): Promise<TransactionSignature>;
     repegAmmCurve(newPeg: BN, marketIndex: BN): Promise<TransactionSignature>;
     updateAmmOracleTwap(marketIndex: BN): Promise<TransactionSignature>;
     resetAmmOracleTwap(marketIndex: BN): Promise<TransactionSignature>;
@@ -30,13 +31,14 @@ export declare class Admin extends ClearingHouse {
     updateOrderFillerRewardStructure(orderFillerRewardStructure: OrderFillerRewardStructure): Promise<TransactionSignature>;
     updateFee(fees: FeeStructure): Promise<TransactionSignature>;
     updateOracleGuardRails(oracleGuardRails: OracleGuardRails): Promise<TransactionSignature>;
-    updateBankWithdrawGuardThreshold(bankIndex: BN, withdrawGuardThreshold: BN): Promise<TransactionSignature>;
-    updateBankIfFactor(bankIndex: BN, userIfFactor: BN, totalIfFactor: BN, liquidationIfFactor: BN): Promise<TransactionSignature>;
-    updateBankInsuranceWithdrawEscrowPeriod(bankIndex: BN, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionSignature>;
+    updateWithdrawGuardThreshold(marketIndex: BN, withdrawGuardThreshold: BN): Promise<TransactionSignature>;
+    updateSpotMarketIfFactor(marketIndex: BN, userIfFactor: BN, totalIfFactor: BN, liquidationIfFactor: BN): Promise<TransactionSignature>;
+    updateInsuranceWithdrawEscrowPeriod(marketIndex: BN, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionSignature>;
     updateLpCooldownTime(marketIndex: BN, cooldownTime: BN): Promise<TransactionSignature>;
     updateMarketOracle(marketIndex: BN, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
     updateMarketMinimumQuoteAssetTradeSize(marketIndex: BN, minimumTradeSize: BN): Promise<TransactionSignature>;
     updateMarketBaseAssetAmountStepSize(marketIndex: BN, stepSize: BN): Promise<TransactionSignature>;
+    updateMarketExpiry(perpMarketIndex: BN, expiryTs: BN): Promise<TransactionSignature>;
     updateWhitelistMint(whitelistMint?: PublicKey): Promise<TransactionSignature>;
     updateDiscountMint(discountMint: PublicKey): Promise<TransactionSignature>;
     updateMaxDeposit(maxDeposit: BN): Promise<TransactionSignature>;
@@ -46,4 +48,5 @@ export declare class Admin extends ClearingHouse {
     updateAuctionDuration(minDuration: BN | number, maxDuration: BN | number): Promise<TransactionSignature>;
     updateMaxBaseAssetAmountRatio(marketIndex: BN, maxBaseAssetAmountRatio: number): Promise<TransactionSignature>;
     updateMaxSlippageRatio(marketIndex: BN, maxSlippageRatio: number): Promise<TransactionSignature>;
+    updateMarketMaxImbalances(marketIndex: BN, unrealizedMaxImbalance: BN, maxRevenueWithdrawPerPeriod: BN, quoteMaxInsurance: BN): Promise<TransactionSignature>;
 }