@drift-labs/sdk 0.1.26 → 0.1.27

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,10 @@ 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>;
+    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,30 @@ class ClearingHouse {
                     fundingRateHistory: state.fundingRateHistory,
                     orderState: yield this.getOrderStatePublicKey(),
                     orderHistory: orderState.orderHistory,
-                    oracle: priceOracle,
                 },
                 remainingAccounts,
             });
         });
     }
-    cancelOrder(orderId) {
+    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 +570,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 +606,7 @@ class ClearingHouse {
                     orderState: yield this.getOrderStatePublicKey(),
                     orderHistory: orderState.orderHistory,
                 },
+                remainingAccounts,
             });
         });
     }

package/lib/constants/markets.d.ts

@@ -6,8 +6,8 @@ export declare type MarketConfig = {
     symbol: string;
     baseAssetSymbol: string;
     marketIndex: BN;
-    devnetPythOracle: string;
-    mainnetPythOracle: string;
+    devnetPublicKey: string;
+    mainnetPublicKey: string;
     launchTs: number;
     oracleSource: OracleSource;
 };

package/lib/constants/markets.js

@@ -9,8 +9,8 @@ exports.Markets = [
         symbol: 'SOL-PERP',
         baseAssetSymbol: 'SOL',
         marketIndex: new __1.BN(0),
-        devnetPythOracle: 'J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix',
-        mainnetPythOracle: 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG',
+        devnetPublicKey: 'J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix',
+        mainnetPublicKey: 'H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG',
         launchTs: 1635209696886,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -20,8 +20,8 @@ exports.Markets = [
         symbol: 'BTC-PERP',
         baseAssetSymbol: 'BTC',
         marketIndex: new __1.BN(1),
-        devnetPythOracle: 'HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J',
-        mainnetPythOracle: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
+        devnetPublicKey: 'HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J',
+        mainnetPublicKey: 'GVXRSBjFk6e6J3NbVPXohDJetcTjaeeuykUpbQF8UoMU',
         launchTs: 1637691088868,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -31,8 +31,8 @@ exports.Markets = [
         symbol: 'ETH-PERP',
         baseAssetSymbol: 'ETH',
         marketIndex: new __1.BN(2),
-        devnetPythOracle: 'EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw',
-        mainnetPythOracle: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
+        devnetPublicKey: 'EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw',
+        mainnetPublicKey: 'JBu1AL4obBcCMqKBBxhpWCNUt136ijcuMZLFvTP7iWdB',
         launchTs: 1637691133472,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -42,8 +42,8 @@ exports.Markets = [
         symbol: 'LUNA-PERP',
         baseAssetSymbol: 'LUNA',
         marketIndex: new __1.BN(3),
-        devnetPythOracle: '8PugCXTAHLM9kfLSQWe2njE5pzAgUdpPk3Nx5zSm7BD3',
-        mainnetPythOracle: '5bmWuR1dgP4avtGYMNKLuxumZTVKGgoN2BCMXWDNL9nY',
+        devnetPublicKey: '8PugCXTAHLM9kfLSQWe2njE5pzAgUdpPk3Nx5zSm7BD3',
+        mainnetPublicKey: '5bmWuR1dgP4avtGYMNKLuxumZTVKGgoN2BCMXWDNL9nY',
         launchTs: 1638821738525,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -52,8 +52,8 @@ exports.Markets = [
         category: ['L1', 'Infra'],
         baseAssetSymbol: 'AVAX',
         marketIndex: new __1.BN(4),
-        devnetPythOracle: 'FVb5h1VmHPfVb1RfqZckchq18GxRv4iKt8T4eVTQAqdz',
-        mainnetPythOracle: 'Ax9ujW5B9oqcv59N8m6f1BpTBq2rGeGaBcpKjC5UYsXU',
+        devnetPublicKey: 'FVb5h1VmHPfVb1RfqZckchq18GxRv4iKt8T4eVTQAqdz',
+        mainnetPublicKey: 'Ax9ujW5B9oqcv59N8m6f1BpTBq2rGeGaBcpKjC5UYsXU',
         launchTs: 1639092501080,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -63,8 +63,8 @@ exports.Markets = [
         category: ['L1', 'Exchange'],
         baseAssetSymbol: 'BNB',
         marketIndex: new __1.BN(5),
-        devnetPythOracle: 'GwzBgrXb4PG59zjce24SF2b9JXbLEjJJTBkmytuEZj1b',
-        mainnetPythOracle: '4CkQJBxhU8EZ2UjhigbtdaPbpTe6mqf811fipYBFbSYN',
+        devnetPublicKey: 'GwzBgrXb4PG59zjce24SF2b9JXbLEjJJTBkmytuEZj1b',
+        mainnetPublicKey: '4CkQJBxhU8EZ2UjhigbtdaPbpTe6mqf811fipYBFbSYN',
         launchTs: 1639523193012,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -74,8 +74,8 @@ exports.Markets = [
         symbol: 'MATIC-PERP',
         baseAssetSymbol: 'MATIC',
         marketIndex: new __1.BN(6),
-        devnetPythOracle: 'FBirwuDFuRAu4iSGc7RGxN5koHB7EJM1wbCmyPuQoGur',
-        mainnetPythOracle: '7KVswB9vkCgeM3SHP7aGDijvdRAHK8P5wi9JXViCrtYh',
+        devnetPublicKey: 'FBirwuDFuRAu4iSGc7RGxN5koHB7EJM1wbCmyPuQoGur',
+        mainnetPublicKey: '7KVswB9vkCgeM3SHP7aGDijvdRAHK8P5wi9JXViCrtYh',
         launchTs: 1641488603564,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -85,8 +85,8 @@ exports.Markets = [
         symbol: 'ATOM-PERP',
         baseAssetSymbol: 'ATOM',
         marketIndex: new __1.BN(7),
-        devnetPythOracle: '7YAze8qFUMkBnyLVdKT4TFUUFui99EwS5gfRArMcrvFk',
-        mainnetPythOracle: 'CrCpTerNqtZvqLcKqz1k13oVeXV9WkMD2zA9hBKXrsbN',
+        devnetPublicKey: '7YAze8qFUMkBnyLVdKT4TFUUFui99EwS5gfRArMcrvFk',
+        mainnetPublicKey: 'CrCpTerNqtZvqLcKqz1k13oVeXV9WkMD2zA9hBKXrsbN',
         launchTs: 1641920238195,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -95,8 +95,8 @@ exports.Markets = [
         symbol: 'DOT-PERP',
         baseAssetSymbol: 'DOT',
         marketIndex: new __1.BN(8),
-        devnetPythOracle: '4dqq5VBpN4EwYb7wyywjjfknvMKu7m78j9mKZRXTj462',
-        mainnetPythOracle: 'EcV1X1gY2yb4KXxjVQtTHTbioum2gvmPnFk4zYAt7zne',
+        devnetPublicKey: '4dqq5VBpN4EwYb7wyywjjfknvMKu7m78j9mKZRXTj462',
+        mainnetPublicKey: 'EcV1X1gY2yb4KXxjVQtTHTbioum2gvmPnFk4zYAt7zne',
         launchTs: 1642629253786,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -106,8 +106,8 @@ exports.Markets = [
         symbol: 'ADA-PERP',
         baseAssetSymbol: 'ADA',
         marketIndex: new __1.BN(9),
-        devnetPythOracle: '8oGTURNmSQkrBS1AQ5NjB2p8qY34UVmMA9ojrw8vnHus',
-        mainnetPythOracle: '3pyn4svBbxJ9Wnn3RVeafyLWfzie6yC5eTig2S62v9SC',
+        devnetPublicKey: '8oGTURNmSQkrBS1AQ5NjB2p8qY34UVmMA9ojrw8vnHus',
+        mainnetPublicKey: '3pyn4svBbxJ9Wnn3RVeafyLWfzie6yC5eTig2S62v9SC',
         launchTs: 1643084413000,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -117,8 +117,8 @@ exports.Markets = [
         symbol: 'ALGO-PERP',
         baseAssetSymbol: 'ALGO',
         marketIndex: new __1.BN(10),
-        devnetPythOracle: 'c1A946dY5NHuVda77C8XXtXytyR3wK1SCP3eA9VRfC3',
-        mainnetPythOracle: 'HqFyq1wh1xKvL7KDqqT7NJeSPdAqsDqnmBisUC2XdXAX',
+        devnetPublicKey: 'c1A946dY5NHuVda77C8XXtXytyR3wK1SCP3eA9VRfC3',
+        mainnetPublicKey: 'HqFyq1wh1xKvL7KDqqT7NJeSPdAqsDqnmBisUC2XdXAX',
         launchTs: 1643686767000,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -128,8 +128,8 @@ exports.Markets = [
         symbol: 'FTT-PERP',
         baseAssetSymbol: 'FTT',
         marketIndex: new __1.BN(11),
-        devnetPythOracle: '6vivTRs5ZPeeXbjo7dfburfaYDWoXjBtdtuYgQRuGfu',
-        mainnetPythOracle: '8JPJJkmDScpcNmBRKGZuPuG2GYAveQgP3t5gFuMymwvF',
+        devnetPublicKey: '6vivTRs5ZPeeXbjo7dfburfaYDWoXjBtdtuYgQRuGfu',
+        mainnetPublicKey: '8JPJJkmDScpcNmBRKGZuPuG2GYAveQgP3t5gFuMymwvF',
         launchTs: 1644382122000,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -139,8 +139,8 @@ exports.Markets = [
         symbol: 'LTC-PERP',
         baseAssetSymbol: 'LTC',
         marketIndex: new __1.BN(12),
-        devnetPythOracle: 'BLArYBCUYhdWiY8PCUTpvFE21iaJq85dvxLk9bYMobcU',
-        mainnetPythOracle: '8RMnV1eD55iqUFJLMguPkYBkq8DCtx81XcmAja93LvRR',
+        devnetPublicKey: 'BLArYBCUYhdWiY8PCUTpvFE21iaJq85dvxLk9bYMobcU',
+        mainnetPublicKey: '8RMnV1eD55iqUFJLMguPkYBkq8DCtx81XcmAja93LvRR',
         launchTs: 1645027429000,
         oracleSource: __1.OracleSource.PYTH,
     },
@@ -150,11 +150,22 @@ exports.Markets = [
         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: 'Ape',
+        category: ['NFT'],
+        symbol: 'APE-PERP',
+        baseAssetSymbol: 'APE',
+        marketIndex: new __1.BN(14),
+        devnetPublicKey: 'AwH6kBrJbkL9JTeqRd7Q59EdWh6UjPtoqoA5M4x4K2fA',
+        mainnetPublicKey: '74zeQpprjNtEghGiC3VEPsR9y4kR2GTd4Rq9YVk9tnjz',
+        launchTs: 1648475932000,
+        oracleSource: __1.OracleSource.SWITCHBOARD,
+    },
     // {
     // 	symbol: 'mSOL-PERP',
     // 	baseAssetSymbol: 'mSOL',

package/lib/idl/clearing_house.json

@@ -2616,7 +2616,7 @@
                     },
                     {
                         "name": "oraclePriceOffset",
-                        "type": "u128"
+                        "type": "i128"
                     },
                     {
                         "name": "padding0",
@@ -4185,6 +4185,11 @@
             "code": 6058,
             "name": "CantCancelPostOnlyOrder",
             "msg": "Cant Cancel Post Only Order"
+        },
+        {
+            "code": 6059,
+            "name": "InvalidOracleOffset",
+            "msg": "InvalidOracleOffset"
         }
     ]
 }

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;

package/lib/orderParams.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
 const types_1 = require("./types");
 const numericConstants_1 = require("./constants/numericConstants");
-function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, reduceOnly, discountToken = false, referrer = false, userOrderId = 0, postOnly = false) {
+function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, reduceOnly, discountToken = false, referrer = false, userOrderId = 0, postOnly = false, oraclePriceOffset = numericConstants_1.ZERO) {
     return {
         orderType: types_1.OrderType.LIMIT,
         userOrderId,
@@ -24,7 +24,7 @@ function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, red
         },
         triggerCondition: types_1.OrderTriggerCondition.ABOVE,
         triggerPrice: numericConstants_1.ZERO,
-        oraclePriceOffset: numericConstants_1.ZERO,
+        oraclePriceOffset,
     };
 }
 exports.getLimitOrderParams = getLimitOrderParams;

package/lib/orders.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="bn.js" />
 import { Market, Order, UserAccount, UserPosition } from './types';
 import { BN, ClearingHouseUser } from '.';
+import { OraclePriceData } from '.';
 export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: Market, order: Order): [UserAccount, UserPosition, Market] | null;
-export declare function calculateBaseAssetAmountMarketCanExecute(market: Market, order: Order): BN;
-export declare function calculateAmountToTradeForLimit(market: Market, order: Order): BN;
+export declare function calculateBaseAssetAmountMarketCanExecute(market: Market, order: Order, oraclePriceData?: OraclePriceData): BN;
+export declare function calculateAmountToTradeForLimit(market: Market, order: Order, oraclePriceData?: OraclePriceData): BN;
 export declare function calculateAmountToTradeForTriggerLimit(market: Market, order: Order): BN;
 export declare function calculateBaseAssetAmountUserCanExecute(market: Market, order: Order, user: ClearingHouseUser): BN;

package/lib/orders.js

@@ -80,9 +80,9 @@ function calculateAmountSwapped(marketBefore, marketAfter) {
         baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(marketAfter.amm.baseAssetReserve),
     };
 }
-function calculateBaseAssetAmountMarketCanExecute(market, order) {
+function calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData) {
     if ((0, types_1.isVariant)(order.orderType, 'limit')) {
-        return calculateAmountToTradeForLimit(market, order);
+        return calculateAmountToTradeForLimit(market, order, oraclePriceData);
     }
     else if ((0, types_1.isVariant)(order.orderType, 'triggerLimit')) {
         return calculateAmountToTradeForTriggerLimit(market, order);
@@ -96,8 +96,15 @@ function calculateBaseAssetAmountMarketCanExecute(market, order) {
     }
 }
 exports.calculateBaseAssetAmountMarketCanExecute = calculateBaseAssetAmountMarketCanExecute;
-function calculateAmountToTradeForLimit(market, order) {
-    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, order.price);
+function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
+    let limitPrice = order.price;
+    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
+        if (!oraclePriceData) {
+            throw Error('Cant calculate limit price for oracle offset oracle without OraclePriceData');
+        }
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+    }
+    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice);
     // Check that directions are the same
     const sameDirection = isSameDirection(direction, order.direction);
     if (!sameDirection) {

package/package.json

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