@drift-labs/sdk 0.1.25-master.0 → 0.1.28

package/lib/accounts/pollingOracleSubscriber.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { OracleEvents, OracleSubscriber } from './types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { OracleClient, OraclePriceData } from '../oracles/types';
+export declare class PollingOracleSubscriber implements OracleSubscriber {
+    isSubscribed: boolean;
+    program: Program;
+    eventEmitter: StrictEventEmitter<EventEmitter, OracleEvents>;
+    publicKey: PublicKey;
+    accountLoader: BulkAccountLoader;
+    oracleClient: OracleClient;
+    callbackId?: string;
+    errorCallbackId?: string;
+    oraclePriceData?: OraclePriceData;
+    constructor(publicKey: PublicKey, oracleClient: OracleClient, accountLoader: BulkAccountLoader);
+    subscribe(): Promise<boolean>;
+    addToAccountLoader(): void;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    assertIsSubscribed(): void;
+    getOraclePriceData(): OraclePriceData;
+}

package/lib/accounts/pollingOracleSubscriber.js

@@ -0,0 +1,79 @@
+"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.PollingOracleSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+class PollingOracleSubscriber {
+    constructor(publicKey, oracleClient, accountLoader) {
+        this.isSubscribed = false;
+        this.publicKey = publicKey;
+        this.oracleClient = oracleClient;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            this.addToAccountLoader();
+            yield this.fetch();
+            this.eventEmitter.emit('update');
+            this.isSubscribed = true;
+            return true;
+        });
+    }
+    addToAccountLoader() {
+        if (this.callbackId) {
+            return;
+        }
+        this.callbackId = this.accountLoader.addAccount(this.publicKey, (buffer) => __awaiter(this, void 0, void 0, function* () {
+            const oraclePriceData = yield this.oracleClient.getOraclePriceDataFromBuffer(buffer);
+            this.oraclePriceData = oraclePriceData;
+            // @ts-ignore
+            this.eventEmitter.emit('oracleUpdate', oraclePriceData);
+            this.eventEmitter.emit('update');
+        }));
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.accountLoader.load();
+            const buffer = this.accountLoader.getAccountData(this.publicKey);
+            this.oraclePriceData = yield this.oracleClient.getOraclePriceDataFromBuffer(buffer);
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            this.accountLoader.removeAccount(this.publicKey, this.callbackId);
+            this.callbackId = undefined;
+            this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+            this.errorCallbackId = undefined;
+            this.isSubscribed = false;
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getOraclePriceData() {
+        this.assertIsSubscribed();
+        return this.oraclePriceData;
+    }
+}
+exports.PollingOracleSubscriber = PollingOracleSubscriber;

package/lib/accounts/types.d.ts

@@ -4,7 +4,7 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
 import { AccountInfo } from '@solana/spl-token';
-import { ClearingHouseConfigType, ClearingHouseUserConfigType } from '..';
+import { ClearingHouseConfigType, ClearingHouseUserConfigType, OraclePriceData } from '..';
 export interface AccountSubscriber<T> {
     data?: T;
     subscribe(onChange: (data: T) => void): Promise<void>;
@@ -84,6 +84,19 @@ export interface TokenAccountSubscriber {
     unsubscribe(): Promise<void>;
     getTokenAccount(): AccountInfo;
 }
+export interface OracleEvents {
+    oracleUpdate: (payload: OraclePriceData) => void;
+    update: void;
+    error: (e: Error) => void;
+}
+export interface OracleSubscriber {
+    eventEmitter: StrictEventEmitter<EventEmitter, OracleEvents>;
+    isSubscribed: boolean;
+    subscribe(): Promise<boolean>;
+    fetch(): Promise<void>;
+    unsubscribe(): Promise<void>;
+    getOraclePriceData(): OraclePriceData;
+}
 export declare type AccountToPoll = {
     key: string;
     publicKey: PublicKey;

package/lib/clearingHouse.d.ts

@@ -121,10 +121,12 @@ export declare class ClearingHouse {
     initializeUserOrdersThenPlaceOrder(orderParams: OrderParams, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
     placeOrder(orderParams: OrderParams, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;
     getPlaceOrderIx(orderParams: OrderParams, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionInstruction>;
-    cancelOrder(orderId: BN): Promise<TransactionSignature>;
-    getCancelOrderIx(orderId: BN): Promise<TransactionInstruction>;
-    cancelOrderByUserId(userOrderId: number): Promise<TransactionSignature>;
-    getCancelOrderByUserIdIx(userOrderId: number): Promise<TransactionInstruction>;
+    expireOrders(userAccountPublicKey: PublicKey, userOrdersAccountPublicKey: PublicKey): Promise<TransactionSignature>;
+    getExpireOrdersIx(userAccountPublicKey: PublicKey, userOrdersAccountPublicKey: PublicKey): Promise<TransactionInstruction>;
+    cancelOrder(orderId: BN, oracle?: PublicKey): Promise<TransactionSignature>;
+    getCancelOrderIx(orderId: BN, oracle?: PublicKey): Promise<TransactionInstruction>;
+    cancelOrderByUserId(userOrderId: number, oracle?: PublicKey): Promise<TransactionSignature>;
+    getCancelOrderByUserIdIx(userOrderId: number, oracle?: PublicKey): Promise<TransactionInstruction>;
     fillOrder(userAccountPublicKey: PublicKey, userOrdersAccountPublicKey: PublicKey, order: Order): Promise<TransactionSignature>;
     getFillOrderIx(userAccountPublicKey: PublicKey, userOrdersAccountPublicKey: PublicKey, order: Order): Promise<TransactionInstruction>;
     initializeUserOrdersThenPlaceAndFillOrder(orderParams: OrderParams, discountToken?: PublicKey, referrer?: PublicKey): Promise<TransactionSignature>;

package/lib/clearingHouse.js

@@ -44,6 +44,7 @@ const web3_js_1 = require("@solana/web3.js");
 const addresses_1 = require("./addresses");
 const utils_1 = require("./tx/utils");
 const clearingHouse_1 = require("./factory/clearingHouse");
+const numericConstants_1 = require("./constants/numericConstants");
 /**
  * # ClearingHouse
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -511,6 +512,13 @@ class ClearingHouse {
                     isSigner: false,
                 });
             }
+            if (!orderParams.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
+                remainingAccounts.push({
+                    pubkey: priceOracle,
+                    isWritable: false,
+                    isSigner: false,
+                });
+            }
             const state = this.getStateAccount();
             const orderState = this.getOrderStateAccount();
             return yield this.program.instruction.placeOrder(orderParams, {
@@ -525,23 +533,54 @@ class ClearingHouse {
                     fundingRateHistory: state.fundingRateHistory,
                     orderState: yield this.getOrderStatePublicKey(),
                     orderHistory: orderState.orderHistory,
-                    oracle: priceOracle,
                 },
                 remainingAccounts,
             });
         });
     }
-    cancelOrder(orderId) {
+    expireOrders(userAccountPublicKey, userOrdersAccountPublicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getExpireOrdersIx(userAccountPublicKey, userOrdersAccountPublicKey)), [], this.opts);
+        });
+    }
+    getExpireOrdersIx(userAccountPublicKey, userOrdersAccountPublicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fillerPublicKey = yield this.getUserAccountPublicKey();
+            const userAccount = yield this.program.account.user.fetch(userAccountPublicKey);
+            const orderState = this.getOrderStateAccount();
+            return yield this.program.instruction.expireOrders({
+                accounts: {
+                    state: yield this.getStatePublicKey(),
+                    filler: fillerPublicKey,
+                    user: userAccountPublicKey,
+                    authority: this.wallet.publicKey,
+                    userPositions: userAccount.positions,
+                    userOrders: userOrdersAccountPublicKey,
+                    orderState: yield this.getOrderStatePublicKey(),
+                    orderHistory: orderState.orderHistory,
+                },
+            });
+        });
+    }
+    cancelOrder(orderId, oracle) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getCancelOrderIx(orderId)), [], this.opts);
+            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getCancelOrderIx(orderId, oracle)), [], this.opts);
         });
     }
-    getCancelOrderIx(orderId) {
+    getCancelOrderIx(orderId, oracle) {
         return __awaiter(this, void 0, void 0, function* () {
             const userAccountPublicKey = yield this.getUserAccountPublicKey();
             const userAccount = yield this.getUserAccount();
             const state = this.getStateAccount();
             const orderState = this.getOrderStateAccount();
+            const remainingAccounts = [];
+            if (oracle) {
+                remainingAccounts.push({
+                    pubkey: oracle,
+                    isWritable: false,
+                    isSigner: false,
+                });
+            }
             return yield this.program.instruction.cancelOrder(orderId, {
                 accounts: {
                     state: yield this.getStatePublicKey(),
@@ -555,20 +594,29 @@ class ClearingHouse {
                     orderState: yield this.getOrderStatePublicKey(),
                     orderHistory: orderState.orderHistory,
                 },
+                remainingAccounts,
             });
         });
     }
-    cancelOrderByUserId(userOrderId) {
+    cancelOrderByUserId(userOrderId, oracle) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getCancelOrderByUserIdIx(userOrderId)), [], this.opts);
+            return yield this.txSender.send((0, utils_1.wrapInTx)(yield this.getCancelOrderByUserIdIx(userOrderId, oracle)), [], this.opts);
         });
     }
-    getCancelOrderByUserIdIx(userOrderId) {
+    getCancelOrderByUserIdIx(userOrderId, oracle) {
         return __awaiter(this, void 0, void 0, function* () {
             const userAccountPublicKey = yield this.getUserAccountPublicKey();
             const userAccount = yield this.getUserAccount();
             const state = this.getStateAccount();
             const orderState = this.getOrderStateAccount();
+            const remainingAccounts = [];
+            if (oracle) {
+                remainingAccounts.push({
+                    pubkey: oracle,
+                    isWritable: false,
+                    isSigner: false,
+                });
+            }
             return yield this.program.instruction.cancelOrderByUserId(userOrderId, {
                 accounts: {
                     state: yield this.getStatePublicKey(),
@@ -582,6 +630,7 @@ class ClearingHouse {
                     orderState: yield this.getOrderStatePublicKey(),
                     orderHistory: orderState.orderHistory,
                 },
+                remainingAccounts,
             });
         });
     }

package/lib/constants/markets.d.ts

@@ -1,11 +1,13 @@
 /// <reference types="bn.js" />
 import { BN, OracleSource } from '../';
 export declare type MarketConfig = {
+    fullName?: string;
+    category?: string[];
     symbol: string;
     baseAssetSymbol: string;
     marketIndex: BN;
-    devnetPythOracle: string;
-    mainnetPythOracle: string;
+    devnetPublicKey: string;
+    mainnetPublicKey: string;
     launchTs: number;
     oracleSource: OracleSource;
 };

package/lib/constants/markets.js

@@ -4,131 +4,179 @@ exports.Markets = void 0;
 const __1 = require("../");
 exports.Markets = [
     {
+        fullName: 'Solana',
+        category: ['L1', 'Infra'],
         symbol: 'SOL-PERP',
         baseAssetSymbol: 'SOL',
         marketIndex: new __1.BN(0),
-        devnetPythOracle: 'J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix',
-        mainnetPythOracle: 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG',
+        devnetPublicKey: 'J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix',
+        mainnetPublicKey: 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG',
         launchTs: 1635209696886,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Bitcoin',
+        category: ['L1', 'Payment'],
         symbol: 'BTC-PERP',
         baseAssetSymbol: 'BTC',
         marketIndex: new __1.BN(1),
-        devnetPythOracle: 'HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J',
-        mainnetPythOracle: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
+        devnetPublicKey: 'HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J',
+        mainnetPublicKey: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
         launchTs: 1637691088868,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Ethereum',
+        category: ['L1', 'Infra'],
         symbol: 'ETH-PERP',
         baseAssetSymbol: 'ETH',
         marketIndex: new __1.BN(2),
-        devnetPythOracle: 'EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw',
-        mainnetPythOracle: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
+        devnetPublicKey: 'EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw',
+        mainnetPublicKey: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
         launchTs: 1637691133472,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Terra',
+        category: ['L1', 'Infra'],
         symbol: 'LUNA-PERP',
         baseAssetSymbol: 'LUNA',
         marketIndex: new __1.BN(3),
-        devnetPythOracle: '8PugCXTAHLM9kfLSQWe2njE5pzAgUdpPk3Nx5zSm7BD3',
-        mainnetPythOracle: '5bmWuR1dgP4avtGYMNKLuxumZTVKGgoN2BCMXWDNL9nY',
+        devnetPublicKey: '8PugCXTAHLM9kfLSQWe2njE5pzAgUdpPk3Nx5zSm7BD3',
+        mainnetPublicKey: '5bmWuR1dgP4avtGYMNKLuxumZTVKGgoN2BCMXWDNL9nY',
         launchTs: 1638821738525,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
         symbol: 'AVAX-PERP',
+        category: ['L1', 'Infra'],
         baseAssetSymbol: 'AVAX',
         marketIndex: new __1.BN(4),
-        devnetPythOracle: 'FVb5h1VmHPfVb1RfqZckchq18GxRv4iKt8T4eVTQAqdz',
-        mainnetPythOracle: 'Ax9ujW5B9oqcv59N8m6f1BpTBq2rGeGaBcpKjC5UYsXU',
+        devnetPublicKey: 'FVb5h1VmHPfVb1RfqZckchq18GxRv4iKt8T4eVTQAqdz',
+        mainnetPublicKey: 'Ax9ujW5B9oqcv59N8m6f1BpTBq2rGeGaBcpKjC5UYsXU',
         launchTs: 1639092501080,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Binance Coin',
         symbol: 'BNB-PERP',
+        category: ['L1', 'Exchange'],
         baseAssetSymbol: 'BNB',
         marketIndex: new __1.BN(5),
-        devnetPythOracle: 'GwzBgrXb4PG59zjce24SF2b9JXbLEjJJTBkmytuEZj1b',
-        mainnetPythOracle: '4CkQJBxhU8EZ2UjhigbtdaPbpTe6mqf811fipYBFbSYN',
+        devnetPublicKey: 'GwzBgrXb4PG59zjce24SF2b9JXbLEjJJTBkmytuEZj1b',
+        mainnetPublicKey: '4CkQJBxhU8EZ2UjhigbtdaPbpTe6mqf811fipYBFbSYN',
         launchTs: 1639523193012,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Polygon',
+        category: ['L1', 'Infra'],
         symbol: 'MATIC-PERP',
         baseAssetSymbol: 'MATIC',
         marketIndex: new __1.BN(6),
-        devnetPythOracle: 'FBirwuDFuRAu4iSGc7RGxN5koHB7EJM1wbCmyPuQoGur',
-        mainnetPythOracle: '7KVswB9vkCgeM3SHP7aGDijvdRAHK8P5wi9JXViCrtYh',
+        devnetPublicKey: 'FBirwuDFuRAu4iSGc7RGxN5koHB7EJM1wbCmyPuQoGur',
+        mainnetPublicKey: '7KVswB9vkCgeM3SHP7aGDijvdRAHK8P5wi9JXViCrtYh',
         launchTs: 1641488603564,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Cosmos',
+        category: ['L1', 'Infra'],
         symbol: 'ATOM-PERP',
         baseAssetSymbol: 'ATOM',
         marketIndex: new __1.BN(7),
-        devnetPythOracle: '7YAze8qFUMkBnyLVdKT4TFUUFui99EwS5gfRArMcrvFk',
-        mainnetPythOracle: 'CrCpTerNqtZvqLcKqz1k13oVeXV9WkMD2zA9hBKXrsbN',
+        devnetPublicKey: '7YAze8qFUMkBnyLVdKT4TFUUFui99EwS5gfRArMcrvFk',
+        mainnetPublicKey: 'CrCpTerNqtZvqLcKqz1k13oVeXV9WkMD2zA9hBKXrsbN',
         launchTs: 1641920238195,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Polkadot',
         symbol: 'DOT-PERP',
         baseAssetSymbol: 'DOT',
         marketIndex: new __1.BN(8),
-        devnetPythOracle: '4dqq5VBpN4EwYb7wyywjjfknvMKu7m78j9mKZRXTj462',
-        mainnetPythOracle: 'EcV1X1gY2yb4KXxjVQtTHTbioum2gvmPnFk4zYAt7zne',
+        devnetPublicKey: '4dqq5VBpN4EwYb7wyywjjfknvMKu7m78j9mKZRXTj462',
+        mainnetPublicKey: 'EcV1X1gY2yb4KXxjVQtTHTbioum2gvmPnFk4zYAt7zne',
         launchTs: 1642629253786,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Cardano',
+        category: ['L1', 'Infra'],
         symbol: 'ADA-PERP',
         baseAssetSymbol: 'ADA',
         marketIndex: new __1.BN(9),
-        devnetPythOracle: '8oGTURNmSQkrBS1AQ5NjB2p8qY34UVmMA9ojrw8vnHus',
-        mainnetPythOracle: '3pyn4svBbxJ9Wnn3RVeafyLWfzie6yC5eTig2S62v9SC',
+        devnetPublicKey: '8oGTURNmSQkrBS1AQ5NjB2p8qY34UVmMA9ojrw8vnHus',
+        mainnetPublicKey: '3pyn4svBbxJ9Wnn3RVeafyLWfzie6yC5eTig2S62v9SC',
         launchTs: 1643084413000,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Algorand',
+        category: ['L1', 'Infra'],
         symbol: 'ALGO-PERP',
         baseAssetSymbol: 'ALGO',
         marketIndex: new __1.BN(10),
-        devnetPythOracle: 'c1A946dY5NHuVda77C8XXtXytyR3wK1SCP3eA9VRfC3',
-        mainnetPythOracle: 'HqFyq1wh1xKvL7KDqqT7NJeSPdAqsDqnmBisUC2XdXAX',
+        devnetPublicKey: 'c1A946dY5NHuVda77C8XXtXytyR3wK1SCP3eA9VRfC3',
+        mainnetPublicKey: 'HqFyq1wh1xKvL7KDqqT7NJeSPdAqsDqnmBisUC2XdXAX',
         launchTs: 1643686767000,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'FTX Coin',
+        category: ['L1', 'Exchange'],
         symbol: 'FTT-PERP',
         baseAssetSymbol: 'FTT',
         marketIndex: new __1.BN(11),
-        devnetPythOracle: '6vivTRs5ZPeeXbjo7dfburfaYDWoXjBtdtuYgQRuGfu',
-        mainnetPythOracle: '8JPJJkmDScpcNmBRKGZuPuG2GYAveQgP3t5gFuMymwvF',
+        devnetPublicKey: '6vivTRs5ZPeeXbjo7dfburfaYDWoXjBtdtuYgQRuGfu',
+        mainnetPublicKey: '8JPJJkmDScpcNmBRKGZuPuG2GYAveQgP3t5gFuMymwvF',
         launchTs: 1644382122000,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Litecoin',
+        category: ['L1', 'Payments'],
         symbol: 'LTC-PERP',
         baseAssetSymbol: 'LTC',
         marketIndex: new __1.BN(12),
-        devnetPythOracle: 'BLArYBCUYhdWiY8PCUTpvFE21iaJq85dvxLk9bYMobcU',
-        mainnetPythOracle: '8RMnV1eD55iqUFJLMguPkYBkq8DCtx81XcmAja93LvRR',
+        devnetPublicKey: 'BLArYBCUYhdWiY8PCUTpvFE21iaJq85dvxLk9bYMobcU',
+        mainnetPublicKey: '8RMnV1eD55iqUFJLMguPkYBkq8DCtx81XcmAja93LvRR',
         launchTs: 1645027429000,
         oracleSource: __1.OracleSource.PYTH,
     },
     {
+        fullName: 'Ripple',
+        category: ['L1', 'Payments'],
         symbol: 'XRP-PERP',
         baseAssetSymbol: 'XRP',
         marketIndex: new __1.BN(13),
-        devnetPythOracle: 'WMW5xc3HypXwTnPesyUT49uLsyHwNURsWAEk39onKuk',
-        mainnetPythOracle: 'WMW5xc3HypXwTnPesyUT49uLsyHwNURsWAEk39onKuk',
+        devnetPublicKey: 'WMW5xc3HypXwTnPesyUT49uLsyHwNURsWAEk39onKuk',
+        mainnetPublicKey: 'WMW5xc3HypXwTnPesyUT49uLsyHwNURsWAEk39onKuk',
         launchTs: 1647543166000,
         oracleSource: __1.OracleSource.SWITCHBOARD,
     },
+    {
+        fullName: 'ApeCoin',
+        category: ['NFT'],
+        symbol: 'APE-PERP',
+        baseAssetSymbol: 'APE',
+        marketIndex: new __1.BN(14),
+        devnetPublicKey: 'AwH6kBrJbkL9JTeqRd7Q59EdWh6UjPtoqoA5M4x4K2fA',
+        mainnetPublicKey: '74zeQpprjNtEghGiC3VEPsR9y4kR2GTd4Rq9YVk9tnjz',
+        launchTs: 1648475932000,
+        oracleSource: __1.OracleSource.SWITCHBOARD,
+    },
+    {
+        fullName: 'DogeCoin',
+        category: ['Meme', 'NFT'],
+        symbol: 'DOGE-PERP',
+        baseAssetSymbol: 'DOGE',
+        marketIndex: new __1.BN(15),
+        devnetPublicKey: '4L6YhY8VvUgmqG5MvJkUJATtzB2rFqdrJwQCmFLv4Jzy',
+        mainnetPublicKey: 'FsSM3s38PX9K7Dn6eGzuE29S2Dsk1Sss1baytTQdCaQj',
+        launchTs: 1648607439000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
     // {
     // 	symbol: 'mSOL-PERP',
     // 	baseAssetSymbol: 'mSOL',

package/lib/idl/clearing_house.json

@@ -677,6 +677,52 @@
                 }
             ]
         },
+        {
+            "name": "expireOrders",
+            "accounts": [
+                {
+                    "name": "state",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "orderState",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "authority",
+                    "isMut": false,
+                    "isSigner": true
+                },
+                {
+                    "name": "filler",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "user",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "userPositions",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "userOrders",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "orderHistory",
+                    "isMut": true,
+                    "isSigner": false
+                }
+            ],
+            "args": []
+        },
         {
             "name": "fillOrder",
             "accounts": [
@@ -2616,7 +2662,7 @@
                     },
                     {
                         "name": "oraclePriceOffset",
-                        "type": "u128"
+                        "type": "i128"
                     },
                     {
                         "name": "padding0",
@@ -3800,6 +3846,9 @@
                     },
                     {
                         "name": "Fill"
+                    },
+                    {
+                        "name": "Expire"
                     }
                 ]
             }
@@ -4180,6 +4229,21 @@
             "code": 6057,
             "name": "InvalidMarginRatio",
             "msg": "Invalid Margin Ratio"
+        },
+        {
+            "code": 6058,
+            "name": "CantCancelPostOnlyOrder",
+            "msg": "Cant Cancel Post Only Order"
+        },
+        {
+            "code": 6059,
+            "name": "InvalidOracleOffset",
+            "msg": "InvalidOracleOffset"
+        },
+        {
+            "code": 6060,
+            "name": "CantExpireOrders",
+            "msg": "CantExpireOrders"
         }
     ]
 }

package/lib/index.d.ts

@@ -10,6 +10,7 @@ export * from './accounts/webSocketClearingHouseAccountSubscriber';
 export * from './accounts/bulkAccountLoader';
 export * from './accounts/bulkUserSubscription';
 export * from './accounts/pollingClearingHouseAccountSubscriber';
+export * from './accounts/pollingOracleSubscriber';
 export * from './accounts/pollingTokenAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses';

package/lib/index.js

@@ -29,6 +29,7 @@ __exportStar(require("./accounts/webSocketClearingHouseAccountSubscriber"), expo
 __exportStar(require("./accounts/bulkAccountLoader"), exports);
 __exportStar(require("./accounts/bulkUserSubscription"), exports);
 __exportStar(require("./accounts/pollingClearingHouseAccountSubscriber"), exports);
+__exportStar(require("./accounts/pollingOracleSubscriber"), exports);
 __exportStar(require("./accounts/pollingTokenAccountSubscriber"), exports);
 __exportStar(require("./accounts/types"), exports);
 __exportStar(require("./addresses"), exports);

package/lib/math/market.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
 import { Market, PositionDirection } from '../types';
+import { OraclePriceData } from '../oracles/types';
 /**
  * Calculates market mark price
  *
@@ -9,3 +10,4 @@ import { Market, PositionDirection } from '../types';
  */
 export declare function calculateMarkPrice(market: Market): BN;
 export declare function calculateNewMarketAfterTrade(baseAssetAmount: BN, direction: PositionDirection, market: Market): Market;
+export declare function calculateMarkOracleSpread(market: Market, oraclePriceData: OraclePriceData): BN;

package/lib/math/market.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateNewMarketAfterTrade = exports.calculateMarkPrice = void 0;
+exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateMarkPrice = void 0;
 const amm_1 = require("./amm");
 /**
  * Calculates market mark price
@@ -22,3 +22,8 @@ function calculateNewMarketAfterTrade(baseAssetAmount, direction, market) {
     return newMarket;
 }
 exports.calculateNewMarketAfterTrade = calculateNewMarketAfterTrade;
+function calculateMarkOracleSpread(market, oraclePriceData) {
+    const markPrice = calculateMarkPrice(market);
+    return markPrice.sub(oraclePriceData.price);
+}
+exports.calculateMarkOracleSpread = calculateMarkOracleSpread;

package/lib/orderParams.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
 import { OrderParams, OrderTriggerCondition, PositionDirection } from './types';
 import { BN } from '@project-serum/anchor';
-export declare function getLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number, postOnly?: boolean): OrderParams;
+export declare function getLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number, postOnly?: boolean, oraclePriceOffset?: BN): OrderParams;
 export declare function getTriggerMarketOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
 export declare function getTriggerLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
 export declare function getMarketOrderParams(marketIndex: BN, direction: PositionDirection, quoteAssetAmount: BN, baseAssetAmount: BN, reduceOnly: boolean, price?: BN, discountToken?: boolean, referrer?: boolean): OrderParams;