@drift-labs/sdk 0.1.23-master.4 → 0.1.26

package/src/index.ts

@@ -2,7 +2,9 @@ import { BN } from '@project-serum/anchor';
 import { PublicKey } from '@solana/web3.js';
 
 export * from './mockUSDCFaucet';
-export * from './pythClient';
+export * from './oracles/types';
+export * from './oracles/pythClient';
+export * from './oracles/switchboardClient';
 export * from './types';
 export * from './constants/markets';
 export * from './accounts/webSocketClearingHouseAccountSubscriber';
@@ -17,6 +19,7 @@ export * from './clearingHouseUser';
 export * from './clearingHouse';
 export * from './factory/clearingHouse';
 export * from './factory/clearingHouseUser';
+export * from './factory/oracleClient';
 export * from './math/conversion';
 export * from './math/funding';
 export * from './math/insuranceFund';

package/src/math/funding.ts

@@ -1,5 +1,4 @@
 import { BN } from '@project-serum/anchor';
-import { PriceData } from '@pythnetwork/client';
 import {
 	AMM_RESERVE_PRECISION,
 	MARK_PRICE_PRECISION,
@@ -8,17 +7,18 @@ import {
 } from '../constants/numericConstants';
 import { Market } from '../types';
 import { calculateMarkPrice } from './market';
+import { OraclePriceData } from '../oracles/types';
 
 /**
  *
  * @param market
- * @param pythClient
+ * @param oraclePriceData
  * @param periodAdjustment
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateAllEstimatedFundingRate(
 	market: Market,
-	oraclePriceData: PriceData,
+	oraclePriceData: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN, BN]> {
 	// periodAdjustment
@@ -65,26 +65,10 @@ export async function calculateAllEstimatedFundingRate(
 		secondsInHour.sub(timeSinceLastOracleTwapUpdate)
 	);
 
-	// verify pyth input is positive for live update
-	let oracleStablePriceNum = 0;
-	let oracleInputCount = 0;
-	if (oraclePriceData.price >= 0) {
-		oracleStablePriceNum += oraclePriceData.price;
-		oracleInputCount += 1;
-	}
-	if (oraclePriceData.previousPrice >= 0) {
-		oracleStablePriceNum += oraclePriceData.previousPrice;
-		oracleInputCount += 1;
-	}
-
-	oracleStablePriceNum = oracleStablePriceNum / oracleInputCount;
-	const oraclePriceStableWithMantissa = new BN(
-		oracleStablePriceNum * MARK_PRICE_PRECISION.toNumber()
-	);
-
+	const oraclePrice = oraclePriceData.price;
 	let oracleTwapWithMantissa = lastOracleTwapWithMantissa;
 
-	const oracleLiveVsTwap = oraclePriceStableWithMantissa
+	const oracleLiveVsTwap = oraclePrice
 		.sub(lastOracleTwapWithMantissa)
 		.abs()
 		.mul(MARK_PRICE_PRECISION)
@@ -95,7 +79,7 @@ export async function calculateAllEstimatedFundingRate(
 	if (oracleLiveVsTwap.lte(MARK_PRICE_PRECISION.mul(new BN(10)))) {
 		oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
 			.mul(lastOracleTwapWithMantissa)
-			.add(timeSinceLastMarkChange.mul(oraclePriceStableWithMantissa))
+			.add(timeSinceLastMarkChange.mul(oraclePrice))
 			.div(timeSinceLastOracleTwapUpdate.add(oracleTwapTimeSinceLastUpdate));
 	}
 
@@ -203,7 +187,7 @@ export async function calculateAllEstimatedFundingRate(
  */
 export async function calculateEstimatedFundingRate(
 	market: Market,
-	oraclePriceData: PriceData,
+	oraclePriceData: OraclePriceData,
 	periodAdjustment: BN = new BN(1),
 	estimationMethod: 'interpolated' | 'lowerbound' | 'capped'
 ): Promise<BN> {
@@ -233,7 +217,7 @@ export async function calculateEstimatedFundingRate(
  */
 export async function calculateLongShortFundingRate(
 	market: Market,
-	oraclePriceData: PriceData,
+	oraclePriceData: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN]> {
 	const [_1, _2, _, cappedAltEst, interpEst] =
@@ -261,7 +245,7 @@ export async function calculateLongShortFundingRate(
  */
 export async function calculateLongShortFundingRateAndLiveTwaps(
 	market: Market,
-	oraclePriceData: PriceData,
+	oraclePriceData: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN]> {
 	const [markTwapLive, oracleTwapLive, _2, cappedAltEst, interpEst] =

package/src/math/orders.ts

@@ -75,3 +75,31 @@ export function isOrderRiskIncreasingInSameDirection(
 
 	return false;
 }
+
+export function isOrderReduceOnly(
+	user: ClearingHouseUser,
+	order: Order
+): boolean {
+	if (isVariant(order.status, 'init')) {
+		return false;
+	}
+
+	const position =
+		user.getUserPosition(order.marketIndex) ||
+		user.getEmptyPosition(order.marketIndex);
+
+	// if position is long and order is long
+	if (position.baseAssetAmount.gt(ZERO) && isVariant(order.direction, 'long')) {
+		return false;
+	}
+
+	// if position is short and order is short
+	if (
+		position.baseAssetAmount.lt(ZERO) &&
+		isVariant(order.direction, 'short')
+	) {
+		return false;
+	}
+
+	return order.baseAssetAmount.abs().lte(position.baseAssetAmount.abs());
+}

package/src/mockUSDCFaucet.js

@@ -0,0 +1,171 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockUSDCFaucet = void 0;
+const anchor = __importStar(require("@project-serum/anchor"));
+const anchor_1 = require("@project-serum/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const mock_usdc_faucet_json_1 = __importDefault(require("./idl/mock_usdc_faucet.json"));
+class MockUSDCFaucet {
+    constructor(connection, wallet, programId, opts) {
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts || anchor_1.Provider.defaultOptions();
+        const provider = new anchor_1.Provider(connection, wallet, this.opts);
+        this.provider = provider;
+        this.program = new anchor_1.Program(mock_usdc_faucet_json_1.default, programId, provider);
+    }
+    getMockUSDCFaucetStatePublicKeyAndNonce() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return anchor.web3.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('mock_usdc_faucet'))], this.program.programId);
+        });
+    }
+    getMockUSDCFaucetStatePublicKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.mockUSDCFaucetStatePublicKey) {
+                return this.mockUSDCFaucetStatePublicKey;
+            }
+            this.mockUSDCFaucetStatePublicKey = (yield this.getMockUSDCFaucetStatePublicKeyAndNonce())[0];
+            return this.mockUSDCFaucetStatePublicKey;
+        });
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stateAccountRPCResponse = yield this.connection.getParsedAccountInfo(yield this.getMockUSDCFaucetStatePublicKey());
+            if (stateAccountRPCResponse.value !== null) {
+                throw new Error('Faucet already initialized');
+            }
+            const fakeUSDCMint = anchor.web3.Keypair.generate();
+            const createUSDCMintAccountIx = web3_js_1.SystemProgram.createAccount({
+                fromPubkey: this.wallet.publicKey,
+                newAccountPubkey: fakeUSDCMint.publicKey,
+                lamports: yield spl_token_1.Token.getMinBalanceRentForExemptMint(this.connection),
+                space: spl_token_1.MintLayout.span,
+                programId: spl_token_1.TOKEN_PROGRAM_ID,
+            });
+            const [mintAuthority, _mintAuthorityNonce] = yield web3_js_1.PublicKey.findProgramAddress([fakeUSDCMint.publicKey.toBuffer()], this.program.programId);
+            const initUSDCMintIx = spl_token_1.Token.createInitMintInstruction(spl_token_1.TOKEN_PROGRAM_ID, fakeUSDCMint.publicKey, 6, mintAuthority, null);
+            const [mockUSDCFaucetStatePublicKey, mockUSDCFaucetStateNonce] = yield this.getMockUSDCFaucetStatePublicKeyAndNonce();
+            return yield this.program.rpc.initialize(mockUSDCFaucetStateNonce, {
+                accounts: {
+                    mockUsdcFaucetState: mockUSDCFaucetStatePublicKey,
+                    admin: this.wallet.publicKey,
+                    mintAccount: fakeUSDCMint.publicKey,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: anchor.web3.SystemProgram.programId,
+                },
+                instructions: [createUSDCMintAccountIx, initUSDCMintIx],
+                signers: [fakeUSDCMint],
+            });
+        });
+    }
+    fetchState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.account.mockUsdcFaucetState.fetch(yield this.getMockUSDCFaucetStatePublicKey());
+        });
+    }
+    mintToUser(userTokenAccount, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.fetchState();
+            return yield this.program.rpc.mintToUser(amount, {
+                accounts: {
+                    mockUsdcFaucetState: yield this.getMockUSDCFaucetStatePublicKey(),
+                    mintAccount: state.mint,
+                    userTokenAccount,
+                    mintAuthority: state.mintAuthority,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    createAssociatedTokenAccountAndMintTo(userPublicKey, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] = yield this.createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount);
+            const tx = new web3_js_1.Transaction().add(createAssociatedAccountIx).add(mintToTx);
+            const txSig = yield this.program.provider.send(tx, [], this.opts);
+            return [associatedTokenPublicKey, txSig];
+        });
+    }
+    createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.fetchState();
+            const associateTokenPublicKey = yield this.getAssosciatedMockUSDMintAddress({ userPubKey: userPublicKey });
+            const createAssociatedAccountIx = spl_token_1.Token.createAssociatedTokenAccountInstruction(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.mint, associateTokenPublicKey, userPublicKey, this.wallet.publicKey);
+            const mintToIx = yield this.program.instruction.mintToUser(amount, {
+                accounts: {
+                    mockUsdcFaucetState: yield this.getMockUSDCFaucetStatePublicKey(),
+                    mintAccount: state.mint,
+                    userTokenAccount: associateTokenPublicKey,
+                    mintAuthority: state.mintAuthority,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+            return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
+        });
+    }
+    getAssosciatedMockUSDMintAddress(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.fetchState();
+            return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.mint, props.userPubKey);
+        });
+    }
+    getTokenAccountInfo(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assosciatedKey = yield this.getAssosciatedMockUSDMintAddress(props);
+            const state = yield this.fetchState();
+            const token = new spl_token_1.Token(this.connection, state.mint, spl_token_1.TOKEN_PROGRAM_ID, 
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            this.provider.payer);
+            return yield token.getAccountInfo(assosciatedKey);
+        });
+    }
+    subscribeToTokenAccount(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokenAccountKey = yield this.getAssosciatedMockUSDMintAddress(props);
+                props.callback(yield this.getTokenAccountInfo(props));
+                // Couldn't find a way to do it using anchor framework subscription, someone on serum discord recommended this way
+                this.connection.onAccountChange(tokenAccountKey, (_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */) => __awaiter(this, void 0, void 0, function* () {
+                    props.callback(yield this.getTokenAccountInfo(props));
+                }));
+                return true;
+            }
+            catch (e) {
+                return false;
+            }
+        });
+    }
+}
+exports.MockUSDCFaucet = MockUSDCFaucet;

package/src/oracles/pythClient.ts

@@ -0,0 +1,49 @@
+import { parsePriceData, PriceData } from '@pythnetwork/client';
+import { Connection, PublicKey } from '@solana/web3.js';
+import { OraclePriceData } from './types';
+import { BN } from '@project-serum/anchor';
+import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
+
+export class PythClient {
+	private connection: Connection;
+
+	public constructor(connection: Connection) {
+		this.connection = connection;
+	}
+
+	public async getPriceData(pricePublicKey: PublicKey): Promise<PriceData> {
+		const account = await this.connection.getAccountInfo(pricePublicKey);
+		return parsePriceData(account.data);
+	}
+
+	public async getOraclePriceData(
+		pricePublicKey: PublicKey
+	): Promise<OraclePriceData> {
+		const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+		return this.getOraclePriceDataFromBuffer(accountInfo.data);
+	}
+
+	public async getOraclePriceDataFromBuffer(
+		buffer: Buffer
+	): Promise<OraclePriceData> {
+		const priceData = parsePriceData(buffer);
+		return {
+			price: convertPythPrice(priceData.price, priceData.exponent),
+			slot: new BN(priceData.lastSlot.toString()),
+			confidence: convertPythPrice(priceData.confidence, priceData.exponent),
+			twap: convertPythPrice(priceData.twap.value, priceData.exponent),
+			twapConfidence: convertPythPrice(
+				priceData.twac.value,
+				priceData.exponent
+			),
+		};
+	}
+}
+
+export function convertPythPrice(price: number, exponent: number): BN {
+	exponent = Math.abs(exponent);
+	const pythPrecision = TEN.pow(new BN(exponent).abs());
+	return new BN(price * Math.pow(10, exponent))
+		.mul(MARK_PRICE_PRECISION)
+		.div(pythPrecision);
+}

package/src/oracles/switchboardClient.ts

@@ -0,0 +1,87 @@
+import {
+	getSwitchboardPid,
+	SwitchboardDecimal,
+} from '@switchboard-xyz/switchboard-v2';
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { DriftEnv } from '../config';
+import { BN, Provider, Program, Idl } from '@project-serum/anchor';
+import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
+import { OracleClient, OraclePriceData } from './types';
+import { Wallet } from '../wallet';
+import switchboardV2Idl from '../idl/switchboard_v2.json';
+
+// cache switchboard program for every client object since itll always be the same
+const programMap = new Map<string, Program>();
+
+export class SwitchboardClient implements OracleClient {
+	connection: Connection;
+	env: DriftEnv;
+
+	public constructor(connection: Connection, env: DriftEnv) {
+		this.connection = connection;
+		this.env = env;
+	}
+
+	public async getOraclePriceData(
+		pricePublicKey: PublicKey
+	): Promise<OraclePriceData> {
+		const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+		return this.getOraclePriceDataFromBuffer(accountInfo.data);
+	}
+
+	public async getOraclePriceDataFromBuffer(
+		buffer: Buffer
+	): Promise<OraclePriceData> {
+		const program = await this.getProgram();
+
+		const aggregatorAccountData =
+			program.account.aggregatorAccountData.coder.accounts.decode(
+				'AggregatorAccountData',
+				buffer
+			);
+		const price = convertSwitchboardDecimal(
+			aggregatorAccountData.latestConfirmedRound.result as SwitchboardDecimal
+		);
+
+		const confidence = convertSwitchboardDecimal(
+			aggregatorAccountData.latestConfirmedRound
+				.stdDeviation as SwitchboardDecimal
+		);
+
+		const slot: BN = aggregatorAccountData.latestConfirmedRound.roundOpenSlot;
+		return {
+			price,
+			slot,
+			confidence,
+		};
+	}
+
+	public async getProgram(): Promise<Program> {
+		if (programMap.has(this.env)) {
+			return programMap.get(this.env);
+		}
+
+		const program = await getSwitchboardProgram(this.env, this.connection);
+		programMap.set(this.env, program);
+		return program;
+	}
+}
+
+async function getSwitchboardProgram(
+	env: DriftEnv,
+	connection: Connection
+): Promise<Program> {
+	const DEFAULT_KEYPAIR = Keypair.fromSeed(new Uint8Array(32).fill(1));
+	const programId = getSwitchboardPid(env);
+	const wallet = new Wallet(DEFAULT_KEYPAIR);
+	const provider = new Provider(connection, wallet, {});
+
+	return new Program(switchboardV2Idl as Idl, programId, provider);
+}
+
+function convertSwitchboardDecimal(switchboardDecimal: SwitchboardDecimal): BN {
+	const switchboardPrecision = TEN.pow(new BN(switchboardDecimal.scale));
+	return switchboardDecimal.mantissa
+		.mul(MARK_PRICE_PRECISION)
+		.div(switchboardPrecision);
+}

package/src/oracles/types.ts

@@ -0,0 +1,15 @@
+import { BN } from '@project-serum/anchor';
+import { PublicKey } from '@solana/web3.js';
+
+export type OraclePriceData = {
+	price: BN;
+	slot: BN;
+	confidence: BN;
+	twap?: BN;
+	twapConfidence?: BN;
+};
+
+export interface OracleClient {
+	getOraclePriceDataFromBuffer(buffer: Buffer): Promise<OraclePriceData>;
+	getOraclePriceData(publicKey: PublicKey): Promise<OraclePriceData>;
+}

package/src/orderParams.ts

@@ -15,7 +15,8 @@ export function getLimitOrderParams(
 	reduceOnly: boolean,
 	discountToken = false,
 	referrer = false,
-	userOrderId = 0
+	userOrderId = 0,
+	postOnly = false
 ): OrderParams {
 	return {
 		orderType: OrderType.LIMIT,
@@ -26,7 +27,7 @@ export function getLimitOrderParams(
 		baseAssetAmount,
 		price,
 		reduceOnly,
-		postOnly: false,
+		postOnly,
 		immediateOrCancel: false,
 		positionLimit: ZERO,
 		padding0: true,

package/src/orders.ts

@@ -255,7 +255,7 @@ export function calculateBaseAssetAmountUserCanExecute(
 	order: Order,
 	user: ClearingHouseUser
 ): BN {
-	const maxLeverage = user.getMaxLeverage('Initial');
+	const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
 	const freeCollateral = user.getFreeCollateral();
 	let quoteAssetAmount: BN;
 	if (isOrderRiskIncreasingInSameDirection(user, order)) {

package/src/types.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 {
+}
+exports.SwapDirection = SwapDirection;
+SwapDirection.ADD = { add: {} };
+SwapDirection.REMOVE = { remove: {} };
+class PositionDirection {
+}
+exports.PositionDirection = PositionDirection;
+PositionDirection.LONG = { long: {} };
+PositionDirection.SHORT = { short: {} };
+class OracleSource {
+}
+exports.OracleSource = OracleSource;
+OracleSource.PYTH = { pyth: {} };
+OracleSource.SWITCHBOARD = { switchboard: {} };
+class OrderType {
+}
+exports.OrderType = OrderType;
+OrderType.LIMIT = { limit: {} };
+OrderType.TRIGGER_MARKET = { triggerMarket: {} };
+OrderType.TRIGGER_LIMIT = { triggerLimit: {} };
+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";
+    TradeSide[TradeSide["Buy"] = 1] = "Buy";
+    TradeSide[TradeSide["Sell"] = 2] = "Sell";
+})(TradeSide = exports.TradeSide || (exports.TradeSide = {}));

package/src/types.ts

@@ -217,6 +217,7 @@ export type OrderRecord = {
 	fee: BN;
 	fillerReward: BN;
 	tradeRecordId: BN;
+	quoteAssetAmountSurplus: BN;
 };
 
 export type StateAccount = {
@@ -267,7 +268,6 @@ export type OrderStateAccount = {
 };
 
 export type MarketsAccount = {
-	accountIndex: BN;
 	markets: Market[];
 };
 
@@ -278,6 +278,9 @@ export type Market = {
 	baseAssetAmountShort: BN;
 	initialized: boolean;
 	openInterest: BN;
+	marginRatioInitial: number;
+	marginRatioMaintenance: number;
+	marginRatioPartial: number;
 };
 
 export type AMM = {
@@ -443,3 +446,5 @@ export type OrderFillerRewardStructure = {
 	rewardDenominator: BN;
 	timeBasedRewardLowerBound: BN;
 };
+
+export type MarginCategory = 'Initial' | 'Partial' | 'Maintenance';

package/lib/pythClient.d.ts

@@ -1,7 +0,0 @@
-import { PriceData } from '@pythnetwork/client';
-import { Connection, PublicKey } from '@solana/web3.js';
-export declare class PythClient {
-    private connection;
-    constructor(connection: Connection);
-    getPriceData(pricePublicKey: PublicKey): Promise<PriceData>;
-}

package/lib/pythClient.js

@@ -1,25 +0,0 @@
-"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.PythClient = void 0;
-const client_1 = require("@pythnetwork/client");
-class PythClient {
-    constructor(connection) {
-        this.connection = connection;
-    }
-    getPriceData(pricePublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const account = yield this.connection.getAccountInfo(pricePublicKey);
-            return (0, client_1.parsePriceData)(account.data);
-        });
-    }
-}
-exports.PythClient = PythClient;

package/src/pythClient.ts

@@ -1,15 +0,0 @@
-import { parsePriceData, PriceData } from '@pythnetwork/client';
-import { Connection, PublicKey } from '@solana/web3.js';
-
-export class PythClient {
-	private connection: Connection;
-
-	public constructor(connection: Connection) {
-		this.connection = connection;
-	}
-
-	public async getPriceData(pricePublicKey: PublicKey): Promise<PriceData> {
-		const account = await this.connection.getAccountInfo(pricePublicKey);
-		return parsePriceData(account.data);
-	}
-}