@drift-labs/sdk 0.1.17 → 0.1.18-orders.0

package/lib/types.d.ts

@@ -24,6 +24,65 @@ export declare class OracleSource {
         switchboard: {};
     };
 }
+export declare class OrderType {
+    static readonly LIMIT: {
+        limit: {};
+    };
+    static readonly STOP: {
+        stop: {};
+    };
+    static readonly STOP_LIMIT: {
+        stopLimit: {};
+    };
+    static readonly MARKET: {
+        market: {};
+    };
+}
+export declare class OrderStatus {
+    static readonly INIT: {
+        init: {};
+    };
+    static readonly OPEN: {
+        open: {};
+    };
+}
+export declare class OrderDiscountTier {
+    static readonly NONE: {
+        none: {};
+    };
+    static readonly FIRST: {
+        first: {};
+    };
+    static readonly SECOND: {
+        second: {};
+    };
+    static readonly THIRD: {
+        third: {};
+    };
+    static readonly FOURTH: {
+        fourth: {};
+    };
+}
+export declare class OrderAction {
+    static readonly PLACE: {
+        place: {};
+    };
+    static readonly CANCEL: {
+        cancel: {};
+    };
+    static readonly FILL: {
+        fill: {};
+    };
+}
+export declare class OrderTriggerCondition {
+    static readonly ABOVE: {
+        above: {};
+    };
+    static readonly BELOW: {
+        below: {};
+    };
+}
+export declare function isVariant(object: unknown, type: string): boolean;
 export declare enum TradeSide {
     None = 0,
     Buy = 1,
@@ -54,6 +113,11 @@ export declare type LiquidationHistoryAccount = {
     head: BN;
     liquidationRecords: LiquidationRecord[];
 };
+export declare type OrderHistoryAccount = {
+    head: BN;
+    lastOrderId: BN;
+    orderRecords: OrderRecord[];
+};
 export declare type DepositRecord = {
     ts: BN;
     recordId: BN;
@@ -145,6 +209,20 @@ export declare type LiquidationRecord = {
     unrealizedPnl: BN;
     marginRatio: BN;
 };
+export declare type OrderRecord = {
+    ts: BN;
+    recordId: BN;
+    order: Order;
+    user: PublicKey;
+    authority: PublicKey;
+    action: OrderAction;
+    filler: PublicKey;
+    baseAssetAmountFilled: BN;
+    quoteAssetAmountFilled: BN;
+    fee: BN;
+    fillerReward: BN;
+    tradeRecordId: BN;
+};
 export declare type StateAccount = {
     admin: PublicKey;
     fundingPaused: boolean;
@@ -182,6 +260,12 @@ export declare type StateAccount = {
     discountMint: PublicKey;
     oracleGuardRails: OracleGuardRails;
     maxDeposit: BN;
+    orderState: PublicKey;
+};
+export declare type OrderStateAccount = {
+    orderHistory: PublicKey;
+    orderFillerRewardStructure: OrderFillerRewardStructure;
+    minOrderQuoteAssetAmount: BN;
 };
 export declare type MarketsAccount = {
     accountIndex: BN;
@@ -217,13 +301,15 @@ export declare type AMM = {
     totalFeeMinusDistributions: BN;
     totalFeeWithdrawn: BN;
     totalFee: BN;
-    minimumTradeSize: BN;
+    minimumQuoteAssetTradeSize: BN;
+    minimumBaseAssetTradeSize: BN;
 };
 export declare type UserPosition = {
     baseAssetAmount: BN;
     lastCumulativeFundingRate: BN;
     marketIndex: BN;
     quoteAssetAmount: BN;
+    openOrders: BN;
 };
 export declare type UserPositionsAccount = {
     positions: UserPosition[];
@@ -235,6 +321,51 @@ export declare type UserAccount = {
     cumulativeDeposits: BN;
     positions: PublicKey;
     totalFeePaid: BN;
+    totalTokenDiscount: BN;
+    totalReferralReward: BN;
+    totalRefereeDiscount: BN;
+};
+export declare type UserOrdersAccount = {
+    orders: Order[];
+    user: PublicKey;
+};
+export declare type Order = {
+    status: OrderStatus;
+    orderType: OrderType;
+    ts: BN;
+    orderId: BN;
+    marketIndex: BN;
+    price: BN;
+    baseAssetAmount: BN;
+    baseAssetAmountFilled: BN;
+    quoteAssetAmount: BN;
+    quoteAssetAmountFilled: BN;
+    fee: BN;
+    direction: PositionDirection;
+    reduceOnly: boolean;
+    triggerPrice: BN;
+    triggerCondition: OrderTriggerCondition;
+    discountTier: OrderDiscountTier;
+    referrer: PublicKey;
+    postOnly: boolean;
+    immediateOrCancel: boolean;
+};
+export declare type OrderParams = {
+    orderType: OrderType;
+    direction: PositionDirection;
+    quoteAssetAmount: BN;
+    baseAssetAmount: BN;
+    price: BN;
+    marketIndex: BN;
+    reduceOnly: boolean;
+    postOnly: boolean;
+    immediateOrCancel: boolean;
+    triggerPrice: BN;
+    triggerCondition: OrderTriggerCondition;
+    optionalAccounts: {
+        discountToken: boolean;
+        referrer: boolean;
+    };
 };
 export interface IWallet {
     signTransaction(tx: Transaction): Promise<Transaction>;
@@ -285,4 +416,8 @@ export declare type OracleGuardRails = {
     };
     useForLiquidations: boolean;
 };
-//# sourceMappingURL=types.d.ts.map
+export declare type OrderFillerRewardStructure = {
+    rewardNumerator: BN;
+    rewardDenominator: BN;
+    timeBasedRewardLowerBound: BN;
+};

package/lib/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TradeSide = exports.OracleSource = exports.PositionDirection = exports.SwapDirection = void 0;
+exports.TradeSide = exports.isVariant = exports.OrderTriggerCondition = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.PositionDirection = exports.SwapDirection = void 0;
 // # Utility Types / Enums / Constants
 class SwapDirection {
 }
@@ -17,6 +17,41 @@ class OracleSource {
 exports.OracleSource = OracleSource;
 OracleSource.PYTH = { pyth: {} };
 OracleSource.SWITCHBOARD = { switchboard: {} };
+class OrderType {
+}
+exports.OrderType = OrderType;
+OrderType.LIMIT = { limit: {} };
+OrderType.STOP = { stop: {} };
+OrderType.STOP_LIMIT = { stopLimit: {} };
+OrderType.MARKET = { market: {} };
+class OrderStatus {
+}
+exports.OrderStatus = OrderStatus;
+OrderStatus.INIT = { init: {} };
+OrderStatus.OPEN = { open: {} };
+class OrderDiscountTier {
+}
+exports.OrderDiscountTier = OrderDiscountTier;
+OrderDiscountTier.NONE = { none: {} };
+OrderDiscountTier.FIRST = { first: {} };
+OrderDiscountTier.SECOND = { second: {} };
+OrderDiscountTier.THIRD = { third: {} };
+OrderDiscountTier.FOURTH = { fourth: {} };
+class OrderAction {
+}
+exports.OrderAction = OrderAction;
+OrderAction.PLACE = { place: {} };
+OrderAction.CANCEL = { cancel: {} };
+OrderAction.FILL = { fill: {} };
+class OrderTriggerCondition {
+}
+exports.OrderTriggerCondition = OrderTriggerCondition;
+OrderTriggerCondition.ABOVE = { above: {} };
+OrderTriggerCondition.BELOW = { below: {} };
+function isVariant(object, type) {
+    return object.hasOwnProperty(type);
+}
+exports.isVariant = isVariant;
 var TradeSide;
 (function (TradeSide) {
     TradeSide[TradeSide["None"] = 0] = "None";

package/lib/util/computeUnits.d.ts

@@ -1,3 +1,2 @@
 import { Connection, Finality, PublicKey } from '@solana/web3.js';
 export declare function findComputeUnitConsumption(programId: PublicKey, connection: Connection, txSignature: string, commitment?: Finality): Promise<number[]>;
-//# sourceMappingURL=computeUnits.d.ts.map

package/lib/util/tps.d.ts

@@ -1,3 +1,2 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 export declare function estimateTps(programId: PublicKey, connection: Connection, failed: boolean): Promise<number>;
-//# sourceMappingURL=tps.d.ts.map

package/lib/wallet.d.ts

@@ -7,4 +7,3 @@ export declare class Wallet implements IWallet {
     signAllTransactions(txs: Transaction[]): Promise<Transaction[]>;
     get publicKey(): PublicKey;
 }
-//# sourceMappingURL=wallet.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.17",
+	"version": "0.1.18-orders.0",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/defaultClearingHouseAccountSubscriber.ts

@@ -11,6 +11,8 @@ import {
 	FundingRateHistoryAccount,
 	LiquidationHistoryAccount,
 	MarketsAccount,
+	OrderHistoryAccount,
+	OrderStateAccount,
 	StateAccount,
 	TradeHistoryAccount,
 } from '../types';
@@ -34,6 +36,8 @@ export class DefaultClearingHouseAccountSubscriber
 	fundingRateHistoryAccountSubscriber?: AccountSubscriber<FundingRateHistoryAccount>;
 	curveHistoryAccountSubscriber?: AccountSubscriber<CurveHistoryAccount>;
 	liquidationHistoryAccountSubscriber?: AccountSubscriber<LiquidationHistoryAccount>;
+	orderStateAccountSubscriber?: AccountSubscriber<OrderStateAccount>;
+	orderHistoryAccountSubscriber?: AccountSubscriber<OrderHistoryAccount>;
 
 	optionalExtraSubscriptions: ClearingHouseAccountTypes[] = [];
 
@@ -92,6 +96,21 @@ export class DefaultClearingHouseAccountSubscriber
 			this.eventEmitter.emit('update');
 		});
 
+		this.orderStateAccountSubscriber = new WebSocketAccountSubscriber(
+			'orderState',
+			this.program,
+			state.orderState
+		);
+
+		await this.orderStateAccountSubscriber.subscribe(
+			(data: OrderStateAccount) => {
+				this.eventEmitter.emit('orderStateAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		const orderState = this.orderStateAccountSubscriber.data;
+
 		// create subscribers for other state accounts
 
 		this.tradeHistoryAccountSubscriber = new WebSocketAccountSubscriber(
@@ -131,6 +150,12 @@ export class DefaultClearingHouseAccountSubscriber
 			state.curveHistory
 		);
 
+		this.orderHistoryAccountSubscriber = new WebSocketAccountSubscriber(
+			'orderHistory',
+			this.program,
+			orderState.orderHistory
+		);
+
 		const extraSusbcribersToUse: {
 			subscriber: AccountSubscriber<any>;
 			eventType: keyof ClearingHouseAccountEvents;
@@ -172,6 +197,12 @@ export class DefaultClearingHouseAccountSubscriber
 				eventType: 'curveHistoryAccountUpdate',
 			});
 
+		if (optionalSubscriptions?.includes('orderHistoryAccount'))
+			extraSusbcribersToUse.push({
+				subscriber: this.orderHistoryAccountSubscriber,
+				eventType: 'orderHistoryAccountUpdate',
+			});
+
 		this.optionalExtraSubscriptions = optionalSubscriptions ?? [];
 
 		// await all subcriptions in parallel to boost performance
@@ -219,6 +250,7 @@ export class DefaultClearingHouseAccountSubscriber
 
 		await this.stateAccountSubscriber.unsubscribe();
 		await this.marketsAccountSubscriber.unsubscribe();
+		await this.orderStateAccountSubscriber.unsubscribe();
 
 		if (this.optionalExtraSubscriptions.includes('tradeHistoryAccount')) {
 			await this.tradeHistoryAccountSubscriber.unsubscribe();
@@ -246,6 +278,10 @@ export class DefaultClearingHouseAccountSubscriber
 			await this.liquidationHistoryAccountSubscriber.unsubscribe();
 		}
 
+		if (this.optionalExtraSubscriptions.includes('orderHistoryAccount')) {
+			await this.orderHistoryAccountSubscriber.unsubscribe();
+		}
+
 		this.isSubscribed = false;
 	}
 
@@ -318,4 +354,15 @@ export class DefaultClearingHouseAccountSubscriber
 		this.assertOptionalIsSubscribed('liquidationHistoryAccount');
 		return this.liquidationHistoryAccountSubscriber.data;
 	}
+
+	public getOrderHistoryAccount(): OrderHistoryAccount {
+		this.assertIsSubscribed();
+		this.assertOptionalIsSubscribed('orderHistoryAccount');
+		return this.orderHistoryAccountSubscriber.data;
+	}
+
+	public getOrderStateAccount(): OrderStateAccount {
+		this.assertIsSubscribed();
+		return this.orderStateAccountSubscriber.data;
+	}
 }

package/src/accounts/defaultHistoryAccountSubscriber.ts

@@ -0,0 +1,176 @@
+import { ClearingHouseAccountEvents, HistoryAccountSubscriber } from './types';
+import { AccountSubscriber, NotSubscribedError } from './types';
+import {
+	CurveHistoryAccount,
+	DepositHistoryAccount,
+	FundingPaymentHistoryAccount,
+	FundingRateHistoryAccount,
+	LiquidationHistoryAccount,
+	TradeHistoryAccount,
+} from '../types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { getClearingHouseStateAccountPublicKey } from '../addresses';
+import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+
+export class DefaultHistoryAccountSubscriber
+	implements HistoryAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
+	tradeHistoryAccountSubscriber?: AccountSubscriber<TradeHistoryAccount>;
+	depositHistoryAccountSubscriber?: AccountSubscriber<DepositHistoryAccount>;
+	fundingPaymentHistoryAccountSubscriber?: AccountSubscriber<FundingPaymentHistoryAccount>;
+	fundingRateHistoryAccountSubscriber?: AccountSubscriber<FundingRateHistoryAccount>;
+	curveHistoryAccountSubscriber?: AccountSubscriber<CurveHistoryAccount>;
+	liquidationHistoryAccountSubscriber?: AccountSubscriber<LiquidationHistoryAccount>;
+
+	public constructor(program: Program) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	public async subscribe(): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		const statePublicKey = await getClearingHouseStateAccountPublicKey(
+			this.program.programId
+		);
+		const state: any = await this.program.account.state.fetch(statePublicKey);
+
+		this.tradeHistoryAccountSubscriber = new WebSocketAccountSubscriber(
+			'tradeHistory',
+			this.program,
+			state.tradeHistory
+		);
+		await this.tradeHistoryAccountSubscriber.subscribe(
+			(data: TradeHistoryAccount) => {
+				this.eventEmitter.emit('tradeHistoryAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.depositHistoryAccountSubscriber = new WebSocketAccountSubscriber(
+			'depositHistory',
+			this.program,
+			state.depositHistory
+		);
+		await this.depositHistoryAccountSubscriber.subscribe(
+			(data: DepositHistoryAccount) => {
+				this.eventEmitter.emit('depositHistoryAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.fundingPaymentHistoryAccountSubscriber =
+			new WebSocketAccountSubscriber(
+				'fundingPaymentHistory',
+				this.program,
+				state.fundingPaymentHistory
+			);
+		await this.fundingPaymentHistoryAccountSubscriber.subscribe(
+			(data: FundingPaymentHistoryAccount) => {
+				this.eventEmitter.emit('fundingPaymentHistoryAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.fundingRateHistoryAccountSubscriber = new WebSocketAccountSubscriber(
+			'fundingRateHistory',
+			this.program,
+			state.fundingRateHistory
+		);
+		await this.fundingRateHistoryAccountSubscriber.subscribe(
+			(data: FundingRateHistoryAccount) => {
+				this.eventEmitter.emit('fundingRateHistoryAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.liquidationHistoryAccountSubscriber = new WebSocketAccountSubscriber(
+			'liquidationHistory',
+			this.program,
+			state.liquidationHistory
+		);
+		await this.liquidationHistoryAccountSubscriber.subscribe(
+			(data: LiquidationHistoryAccount) => {
+				this.eventEmitter.emit('liquidationHistoryAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.curveHistoryAccountSubscriber = new WebSocketAccountSubscriber(
+			'curveHistory',
+			this.program,
+			state.curveHistory
+		);
+		await this.curveHistoryAccountSubscriber.subscribe(
+			(data: CurveHistoryAccount) => {
+				this.eventEmitter.emit('curveHistoryAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.eventEmitter.emit('update');
+
+		this.isSubscribed = true;
+		return true;
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		await this.tradeHistoryAccountSubscriber.unsubscribe();
+		await this.fundingRateHistoryAccountSubscriber.unsubscribe();
+		await this.fundingPaymentHistoryAccountSubscriber.unsubscribe();
+		await this.depositHistoryAccountSubscriber.unsubscribe();
+		await this.curveHistoryAccountSubscriber.unsubscribe();
+		await this.liquidationHistoryAccountSubscriber.unsubscribe();
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getTradeHistoryAccount(): TradeHistoryAccount {
+		this.assertIsSubscribed();
+		return this.tradeHistoryAccountSubscriber.data;
+	}
+
+	public getDepositHistoryAccount(): DepositHistoryAccount {
+		this.assertIsSubscribed();
+		return this.depositHistoryAccountSubscriber.data;
+	}
+
+	public getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount {
+		this.assertIsSubscribed();
+		return this.fundingPaymentHistoryAccountSubscriber.data;
+	}
+
+	public getFundingRateHistoryAccount(): FundingRateHistoryAccount {
+		this.assertIsSubscribed();
+		return this.fundingRateHistoryAccountSubscriber.data;
+	}
+
+	public getCurveHistoryAccount(): CurveHistoryAccount {
+		this.assertIsSubscribed();
+		return this.curveHistoryAccountSubscriber.data;
+	}
+
+	public getLiquidationHistoryAccount(): LiquidationHistoryAccount {
+		this.assertIsSubscribed();
+		return this.liquidationHistoryAccountSubscriber.data;
+	}
+}

package/src/accounts/defaultUserAccountSubscriber.ts

@@ -8,9 +8,12 @@ import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
-import { getUserAccountPublicKey } from '../addresses';
+import {
+	getUserAccountPublicKey,
+	getUserOrdersAccountPublicKey,
+} from '../addresses';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
-import { UserAccount, UserPositionsAccount } from '../types';
+import { UserAccount, UserOrdersAccount, UserPositionsAccount } from '../types';
 
 export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 	isSubscribed: boolean;
@@ -20,6 +23,7 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 
 	userDataAccountSubscriber: AccountSubscriber<UserAccount>;
 	userPositionsAccountSubscriber: AccountSubscriber<UserPositionsAccount>;
+	userOrdersAccountSubscriber: AccountSubscriber<UserOrdersAccount>;
 
 	public constructor(program: Program, authority: PublicKey) {
 		this.isSubscribed = false;
@@ -61,6 +65,23 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 			}
 		);
 
+		const userOrdersPublicKey = await getUserOrdersAccountPublicKey(
+			this.program.programId,
+			this.authority
+		);
+
+		this.userOrdersAccountSubscriber = new WebSocketAccountSubscriber(
+			'userOrders',
+			this.program,
+			userOrdersPublicKey
+		);
+		await this.userOrdersAccountSubscriber.subscribe(
+			(data: UserOrdersAccount) => {
+				this.eventEmitter.emit('userOrdersData', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
 		this.eventEmitter.emit('update');
 		this.isSubscribed = true;
 		return true;
@@ -70,6 +91,7 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 		await Promise.all([
 			this.userDataAccountSubscriber.fetch(),
 			this.userPositionsAccountSubscriber.fetch(),
+			this.userOrdersAccountSubscriber.fetch(),
 		]);
 	}
 
@@ -80,6 +102,7 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 
 		this.userDataAccountSubscriber.unsubscribe();
 		this.userPositionsAccountSubscriber.unsubscribe();
+		this.userOrdersAccountSubscriber.unsubscribe();
 
 		this.isSubscribed = false;
 	}
@@ -101,4 +124,8 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 		this.assertIsSubscribed();
 		return this.userPositionsAccountSubscriber.data;
 	}
+
+	public getUserOrdersAccount(): UserOrdersAccount {
+		return this.userOrdersAccountSubscriber.data;
+	}
 }

package/src/accounts/types.ts

@@ -5,9 +5,12 @@ import {
 	FundingRateHistoryAccount,
 	LiquidationHistoryAccount,
 	MarketsAccount,
+	OrderHistoryAccount,
+	OrderStateAccount,
 	StateAccount,
 	TradeHistoryAccount,
 	UserAccount,
+	UserOrdersAccount,
 	UserPositionsAccount,
 } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
@@ -35,6 +38,8 @@ export interface ClearingHouseAccountEvents {
 	liquidationHistoryAccountUpdate: (payload: LiquidationHistoryAccount) => void;
 	depositHistoryAccountUpdate: (payload: DepositHistoryAccount) => void;
 	curveHistoryAccountUpdate: (payload: CurveHistoryAccount) => void;
+	orderHistoryAccountUpdate: (payload: OrderHistoryAccount) => void;
+	orderStateAccountUpdate: (payload: OrderStateAccount) => void;
 	update: void;
 }
 
@@ -44,7 +49,8 @@ export type ClearingHouseAccountTypes =
 	| 'fundingPaymentHistoryAccount'
 	| 'fundingRateHistoryAccount'
 	| 'curveHistoryAccount'
-	| 'liquidationHistoryAccount';
+	| 'liquidationHistoryAccount'
+	| 'orderHistoryAccount';
 
 export interface ClearingHouseAccountSubscriber {
 	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
@@ -66,11 +72,41 @@ export interface ClearingHouseAccountSubscriber {
 	getFundingRateHistoryAccount(): FundingRateHistoryAccount;
 	getCurveHistoryAccount(): CurveHistoryAccount;
 	getLiquidationHistoryAccount(): LiquidationHistoryAccount;
+	getOrderStateAccount(): OrderStateAccount;
+	getOrderHistoryAccount(): OrderHistoryAccount;
+}
+
+export interface HistoryAccountEvents {
+	fundingPaymentHistoryAccountUpdate: (
+		payload: FundingPaymentHistoryAccount
+	) => void;
+	fundingRateHistoryAccountUpdate: (payload: FundingRateHistoryAccount) => void;
+	tradeHistoryAccountUpdate: (payload: TradeHistoryAccount) => void;
+	liquidationHistoryAccountUpdate: (payload: LiquidationHistoryAccount) => void;
+	depositHistoryAccountUpdate: (payload: DepositHistoryAccount) => void;
+	curveHistoryAccountUpdate: (payload: CurveHistoryAccount) => void;
+	update: void;
+}
+
+export interface HistoryAccountSubscriber {
+	eventEmitter: StrictEventEmitter<EventEmitter, HistoryAccountEvents>;
+	isSubscribed: boolean;
+
+	subscribe(): Promise<boolean>;
+	unsubscribe(): Promise<void>;
+
+	getTradeHistoryAccount(): TradeHistoryAccount;
+	getDepositHistoryAccount(): DepositHistoryAccount;
+	getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
+	getFundingRateHistoryAccount(): FundingRateHistoryAccount;
+	getCurveHistoryAccount(): CurveHistoryAccount;
+	getLiquidationHistoryAccount(): LiquidationHistoryAccount;
 }
 
 export interface UserAccountEvents {
 	userAccountData: (payload: UserAccount) => void;
 	userPositionsData: (payload: UserPositionsAccount) => void;
+	userOrdersData: (payload: UserOrdersAccount) => void;
 	update: void;
 }
 
@@ -84,4 +120,5 @@ export interface UserAccountSubscriber {
 
 	getUserAccount(): UserAccount;
 	getUserPositionsAccount(): UserPositionsAccount;
+	getUserOrdersAccount(): UserOrdersAccount;
 }