@drift-labs/sdk 0.1.30-master.0 → 0.1.30-master.3

package/lib/math/amm.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = void 0;
+exports.calculateBudgetedPeg = exports.calculateBudgetedK = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.calculateRepegCost = exports.calculateAdjustKCost = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
+const position_1 = require("./position");
 const types_1 = require("../types");
 const assert_1 = require("../assert/assert");
 const __1 = require("..");
@@ -87,6 +88,92 @@ function getSwapDirection(inputAssetType, positionDirection) {
     return types_1.SwapDirection.ADD;
 }
 exports.getSwapDirection = getSwapDirection;
+/**
+ * Helper function calculating adjust k cost
+ * @param market
+ * @param marketIndex
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+function calculateAdjustKCost(market, marketIndex, numerator, denomenator) {
+    const netUserPosition = {
+        baseAssetAmount: market.baseAssetAmount,
+        lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+        marketIndex: new anchor_1.BN(marketIndex),
+        quoteAssetAmount: new anchor_1.BN(0),
+        openOrders: new anchor_1.BN(0),
+    };
+    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
+    const marketNewK = Object.assign({}, market);
+    marketNewK.amm = Object.assign({}, market.amm);
+    marketNewK.amm.baseAssetReserve = market.amm.baseAssetReserve
+        .mul(numerator)
+        .div(denomenator);
+    marketNewK.amm.quoteAssetReserve = market.amm.quoteAssetReserve
+        .mul(numerator)
+        .div(denomenator);
+    marketNewK.amm.sqrtK = market.amm.sqrtK.mul(numerator).div(denomenator);
+    netUserPosition.quoteAssetAmount = currentValue;
+    const cost = (0, __1.calculatePositionPNL)(marketNewK, netUserPosition);
+    const p = numericConstants_1.PEG_PRECISION.mul(numerator).div(denomenator);
+    const x = market.amm.baseAssetReserve;
+    const y = market.amm.quoteAssetReserve;
+    const delta = market.baseAssetAmount;
+    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const numer1 = numericConstants_1.PEG_PRECISION.sub(p).mul(y).div(numericConstants_1.PEG_PRECISION);
+    const numer20 = k
+        .mul(p)
+        .mul(p)
+        .div(numericConstants_1.PEG_PRECISION)
+        .div(numericConstants_1.PEG_PRECISION)
+        .div(x.mul(p).div(numericConstants_1.PEG_PRECISION).add(delta));
+    const numer21 = k.div(x.add(delta));
+    const formulaCost = numer21
+        .sub(numer20)
+        .sub(numer1)
+        .mul(market.amm.pegMultiplier)
+        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    console.log((0, __1.convertToNumber)(formulaCost, numericConstants_1.QUOTE_PRECISION));
+    // p.div(p.mul(x).add(delta)).sub()
+    return cost;
+}
+exports.calculateAdjustKCost = calculateAdjustKCost;
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param market
+ * @param marketIndex
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+function calculateRepegCost(market, marketIndex, newPeg) {
+    const netUserPosition = {
+        baseAssetAmount: market.baseAssetAmount,
+        lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+        marketIndex: new anchor_1.BN(marketIndex),
+        quoteAssetAmount: new anchor_1.BN(0),
+        openOrders: new anchor_1.BN(0),
+    };
+    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
+    netUserPosition.quoteAssetAmount = currentValue;
+    const prevMarketPrice = (0, __1.calculateMarkPrice)(market);
+    const marketNewPeg = Object.assign({}, market);
+    marketNewPeg.amm = Object.assign({}, market.amm);
+    // const marketNewPeg = JSON.parse(JSON.stringify(market));
+    marketNewPeg.amm.pegMultiplier = newPeg;
+    console.log('Price moves from', (0, __1.convertToNumber)(prevMarketPrice), 'to', (0, __1.convertToNumber)((0, __1.calculateMarkPrice)(marketNewPeg)));
+    const cost = (0, __1.calculatePositionPNL)(marketNewPeg, netUserPosition);
+    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const newQuoteAssetReserve = k.div(market.amm.baseAssetReserve.add(netUserPosition.baseAssetAmount));
+    const deltaQuoteAssetReserves = newQuoteAssetReserve.sub(market.amm.quoteAssetReserve);
+    const cost2 = deltaQuoteAssetReserves
+        .mul(market.amm.pegMultiplier.sub(newPeg))
+        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    console.log((0, __1.convertToNumber)(cost2, numericConstants_1.QUOTE_PRECISION));
+    return cost;
+}
+exports.calculateRepegCost = calculateRepegCost;
 /**
  * Helper function calculating terminal price of amm
  *
@@ -132,3 +219,66 @@ function calculateMaxBaseAssetAmountToTrade(amm, limit_price) {
     }
 }
 exports.calculateMaxBaseAssetAmountToTrade = calculateMaxBaseAssetAmountToTrade;
+function calculateBudgetedK(market, cost) {
+    // wolframalpha.com
+    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+    // todo: assumes k = x * y
+    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+    // const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const x = market.amm.baseAssetReserve;
+    const y = market.amm.quoteAssetReserve;
+    const d = market.baseAssetAmount;
+    const Q = market.amm.pegMultiplier;
+    const C = cost.mul(new anchor_1.BN(-1));
+    const numer1 = y.mul(d).mul(Q).div(numericConstants_1.AMM_RESERVE_PRECISION).div(numericConstants_1.PEG_PRECISION);
+    const numer2 = C.mul(x.add(d)).div(numericConstants_1.QUOTE_PRECISION);
+    const denom1 = C.mul(x)
+        .mul(x.add(d))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.QUOTE_PRECISION);
+    const denom2 = y
+        .mul(d)
+        .mul(d)
+        .mul(Q)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.PEG_PRECISION);
+    const numerator = d
+        .mul(numer1.add(numer2))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    const denominator = denom1
+        .add(denom2)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    console.log(numerator, denominator);
+    // const p = (numerator).div(denominator);
+    // const formulaCost = (numer21.sub(numer20).sub(numer1)).mul(market.amm.pegMultiplier).div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+    // console.log(convertToNumber(formulaCost, QUOTE_PRECISION))
+    return [numerator, denominator];
+}
+exports.calculateBudgetedK = calculateBudgetedK;
+function calculateBudgetedPeg(market, cost) {
+    // wolframalpha.com
+    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
+    // todo: assumes k = x * y
+    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const x = market.amm.baseAssetReserve;
+    const y = market.amm.quoteAssetReserve;
+    const d = market.baseAssetAmount;
+    const Q = market.amm.pegMultiplier;
+    const C = cost.mul(new anchor_1.BN(-1));
+    const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
+    const deltaPegMultiplier = C.mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO))
+        .mul(numericConstants_1.PEG_PRECISION)
+        .div(numericConstants_1.QUOTE_PRECISION);
+    console.log(Q.toNumber(), 'change by', deltaPegMultiplier.toNumber() / numericConstants_1.MARK_PRICE_PRECISION.toNumber());
+    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.MARK_PRICE_PRECISION));
+    return newPeg;
+}
+exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/lib/util/promiseTimeout.d.ts

@@ -0,0 +1 @@
+export declare function promiseTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | null>;

package/lib/util/promiseTimeout.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTimeout = void 0;
+function promiseTimeout(promise, timeoutMs) {
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => resolve(null), timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).then((result) => {
+        clearTimeout(timeoutId);
+        return result;
+    });
+}
+exports.promiseTimeout = promiseTimeout;

package/package.json

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

package/src/accounts/bulkAccountLoader.ts

@@ -1,6 +1,7 @@
 import { Commitment, Connection, PublicKey } from '@solana/web3.js';
 import { v4 as uuidv4 } from 'uuid';
 import { AccountData } from './types';
+import { promiseTimeout } from '../util/promiseTimeout';
 
 type AccountToLoad = {
 	publicKey: PublicKey;
@@ -10,7 +11,6 @@ type AccountToLoad = {
 const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
 
 const oneMinute = 60 * 1000;
-const fiveMinutes = 5 * 60 * 1000;
 
 export class BulkAccountLoader {
 	connection: Connection;
@@ -24,7 +24,7 @@ export class BulkAccountLoader {
 	loadPromise?: Promise<void>;
 	loadPromiseResolver: () => void;
 	loggingEnabled = false;
-	lastUpdate = Date.now();
+	lastTimeLoadingPromiseCleared = Date.now();
 
 	public constructor(
 		connection: Connection,
@@ -107,12 +107,20 @@ export class BulkAccountLoader {
 
 	public async load(): Promise<void> {
 		if (this.loadPromise) {
-			this.log(`Load promise exists. Returning early`);
-			return this.loadPromise;
+			const now = Date.now();
+			if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
+				this.log(`Load promise hasnt been clearing for one minute. Clearing.`);
+				this.loadPromise = undefined;
+			} else {
+				this.log(`Load promise exists. Returning early`);
+				return this.loadPromise;
+			}
 		}
+
 		this.loadPromise = new Promise((resolver) => {
 			this.loadPromiseResolver = resolver;
 		});
+		this.lastTimeLoadingPromiseCleared = Date.now();
 
 		this.log(`Loading`);
 
@@ -139,18 +147,6 @@ export class BulkAccountLoader {
 			this.log(`resetting load promise`);
 			this.loadPromiseResolver();
 			this.loadPromise = undefined;
-
-			const now = Date.now();
-			if (now - this.lastUpdate > fiveMinutes) {
-				this.log(
-					"Haven't seen updated account in five minutes. Bulk account loader creating new Connection Object"
-				);
-				this.connection = new Connection(
-					// @ts-ignore
-					this.connection._rpcEndpoint,
-					this.connection.commitment
-				);
-			}
 		}
 	}
 
@@ -167,15 +163,15 @@ export class BulkAccountLoader {
 			{ commitment: this.commitment },
 		];
 
-		// @ts-ignore
-		const rpcResponse = await this.connection._rpcRequest(
-			'getMultipleAccounts',
-			args
+		const rpcResponse: any | null = await promiseTimeout(
+			// @ts-ignore
+			this.connection._rpcRequest('getMultipleAccounts', args),
+			10 * 1000 // 30 second timeout
 		);
 
-		const oneMinuteSinceLastUpdate = Date.now() - this.lastUpdate > oneMinute;
-		if (oneMinuteSinceLastUpdate) {
-			this.log('rpcResponse ' + JSON.stringify(rpcResponse));
+		if (rpcResponse === null) {
+			this.log('request to rpc timed out', true);
+			return;
 		}
 
 		const newSlot = rpcResponse.result.context.slot;
@@ -192,10 +188,6 @@ export class BulkAccountLoader {
 				newBuffer = Buffer.from(raw, dataType);
 			}
 
-			if (oneMinuteSinceLastUpdate) {
-				this.log('oldRPCResponse' + oldRPCResponse);
-			}
-
 			if (!oldRPCResponse) {
 				this.log('No old rpc response, updating account data');
 				this.accountData.set(key, {
@@ -203,7 +195,6 @@ export class BulkAccountLoader {
 					buffer: newBuffer,
 				});
 				this.handleAccountCallbacks(accountToLoad, newBuffer);
-				this.lastUpdate = Date.now();
 				continue;
 			}
 
@@ -220,12 +211,11 @@ export class BulkAccountLoader {
 					buffer: newBuffer,
 				});
 				this.handleAccountCallbacks(accountToLoad, newBuffer);
-				this.lastUpdate = Date.now();
 			} else {
 				this.log('unable to update account for newest slot');
 				this.log('oldBuffer ' + oldBuffer);
 				this.log('newBuffer ' + newBuffer);
-				this.log('buffers equal ' + newBuffer.equals(oldBuffer));
+				this.log('buffers equal ' + newBuffer?.equals(oldBuffer));
 			}
 		}
 	}
@@ -262,8 +252,8 @@ export class BulkAccountLoader {
 		}
 	}
 
-	public log(msg: string): void {
-		if (this.loggingEnabled) {
+	public log(msg: string, force = false): void {
+		if (this.loggingEnabled || force) {
 			console.log(msg);
 		}
 	}

package/src/accounts/pollingClearingHouseAccountSubscriber.ts

@@ -24,6 +24,8 @@ import { getClearingHouseStateAccountPublicKey } from '../addresses';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { capitalize } from './utils';
 import { ClearingHouseConfigType } from '../factory/clearingHouse';
+import { PublicKey } from '@solana/web3.js';
+import { CLEARING_HOUSE_STATE_ACCOUNTS } from '../constants/accounts';
 
 export class PollingClearingHouseAccountSubscriber
 	implements ClearingHouseAccountSubscriber
@@ -98,44 +100,38 @@ export class PollingClearingHouseAccountSubscriber
 			return;
 		}
 
-		const statePublicKey = await getClearingHouseStateAccountPublicKey(
-			this.program.programId
-		);
-
-		const state = (await this.program.account.state.fetch(
-			statePublicKey
-		)) as StateAccount;
+		const accounts = await this.getClearingHouseAccounts();
 
-		this.accountsToPoll.set(statePublicKey.toString(), {
+		this.accountsToPoll.set(accounts.state.toString(), {
 			key: 'state',
-			publicKey: statePublicKey,
+			publicKey: accounts.state,
 			eventType: 'stateAccountUpdate',
 		});
 
-		this.accountsToPoll.set(state.markets.toString(), {
+		this.accountsToPoll.set(accounts.markets.toString(), {
 			key: 'markets',
-			publicKey: state.markets,
+			publicKey: accounts.markets,
 			eventType: 'marketsAccountUpdate',
 		});
 
-		this.accountsToPoll.set(state.orderState.toString(), {
+		this.accountsToPoll.set(accounts.orderState.toString(), {
 			key: 'orderState',
-			publicKey: state.orderState,
+			publicKey: accounts.orderState,
 			eventType: 'orderStateAccountUpdate',
 		});
 
 		if (this.optionalExtraSubscriptions?.includes('tradeHistoryAccount')) {
-			this.accountsToPoll.set(state.tradeHistory.toString(), {
+			this.accountsToPoll.set(accounts.tradeHistory.toString(), {
 				key: 'tradeHistory',
-				publicKey: state.tradeHistory,
+				publicKey: accounts.tradeHistory,
 				eventType: 'tradeHistoryAccountUpdate',
 			});
 		}
 
 		if (this.optionalExtraSubscriptions?.includes('depositHistoryAccount')) {
-			this.accountsToPoll.set(state.depositHistory.toString(), {
+			this.accountsToPoll.set(accounts.depositHistory.toString(), {
 				key: 'depositHistory',
-				publicKey: state.depositHistory,
+				publicKey: accounts.depositHistory,
 				eventType: 'depositHistoryAccountUpdate',
 			});
 		}
@@ -143,9 +139,9 @@ export class PollingClearingHouseAccountSubscriber
 		if (
 			this.optionalExtraSubscriptions?.includes('fundingPaymentHistoryAccount')
 		) {
-			this.accountsToPoll.set(state.fundingPaymentHistory.toString(), {
+			this.accountsToPoll.set(accounts.fundingPaymentHistory.toString(), {
 				key: 'fundingPaymentHistory',
-				publicKey: state.fundingPaymentHistory,
+				publicKey: accounts.fundingPaymentHistory,
 				eventType: 'fundingPaymentHistoryAccountUpdate',
 			});
 		}
@@ -153,17 +149,17 @@ export class PollingClearingHouseAccountSubscriber
 		if (
 			this.optionalExtraSubscriptions?.includes('fundingRateHistoryAccount')
 		) {
-			this.accountsToPoll.set(state.fundingRateHistory.toString(), {
+			this.accountsToPoll.set(accounts.fundingRateHistory.toString(), {
 				key: 'fundingRateHistory',
-				publicKey: state.fundingRateHistory,
+				publicKey: accounts.fundingRateHistory,
 				eventType: 'fundingRateHistoryAccountUpdate',
 			});
 		}
 
 		if (this.optionalExtraSubscriptions?.includes('curveHistoryAccount')) {
-			this.accountsToPoll.set(state.extendedCurveHistory.toString(), {
+			this.accountsToPoll.set(accounts.extendedCurveHistory.toString(), {
 				key: 'extendedCurveHistory',
-				publicKey: state.extendedCurveHistory,
+				publicKey: accounts.extendedCurveHistory,
 				eventType: 'curveHistoryAccountUpdate',
 			});
 		}
@@ -171,24 +167,58 @@ export class PollingClearingHouseAccountSubscriber
 		if (
 			this.optionalExtraSubscriptions?.includes('liquidationHistoryAccount')
 		) {
-			this.accountsToPoll.set(state.liquidationHistory.toString(), {
+			this.accountsToPoll.set(accounts.liquidationHistory.toString(), {
 				key: 'liquidationHistory',
-				publicKey: state.liquidationHistory,
+				publicKey: accounts.liquidationHistory,
 				eventType: 'liquidationHistoryAccountUpdate',
 			});
 		}
 
+		if (this.optionalExtraSubscriptions?.includes('orderHistoryAccount')) {
+			this.accountsToPoll.set(accounts.orderHistory.toString(), {
+				key: 'orderHistory',
+				publicKey: accounts.orderHistory,
+				eventType: 'orderHistoryAccountUpdate',
+			});
+		}
+	}
+
+	async getClearingHouseAccounts(): Promise<ClearingHouseAccounts> {
+		// Skip extra calls to rpc if we already know all the accounts
+		if (CLEARING_HOUSE_STATE_ACCOUNTS[this.program.programId.toString()]) {
+			return CLEARING_HOUSE_STATE_ACCOUNTS[this.program.programId.toString()];
+		}
+
+		const statePublicKey = await getClearingHouseStateAccountPublicKey(
+			this.program.programId
+		);
+
+		const state = (await this.program.account.state.fetch(
+			statePublicKey
+		)) as StateAccount;
+
+		const accounts = {
+			state: statePublicKey,
+			markets: state.markets,
+			orderState: state.orderState,
+			tradeHistory: state.tradeHistory,
+			depositHistory: state.depositHistory,
+			fundingPaymentHistory: state.fundingPaymentHistory,
+			fundingRateHistory: state.fundingRateHistory,
+			extendedCurveHistory: state.extendedCurveHistory,
+			liquidationHistory: state.liquidationHistory,
+			orderHistory: undefined,
+		};
+
 		if (this.optionalExtraSubscriptions?.includes('orderHistoryAccount')) {
 			const orderState = (await this.program.account.orderState.fetch(
 				state.orderState
 			)) as OrderStateAccount;
 
-			this.accountsToPoll.set(orderState.orderHistory.toString(), {
-				key: 'orderHistory',
-				publicKey: orderState.orderHistory,
-				eventType: 'orderHistoryAccountUpdate',
-			});
+			accounts.orderHistory = orderState.orderHistory;
 		}
+
+		return accounts;
 	}
 
 	async addToAccountLoader(): Promise<void> {
@@ -324,3 +354,16 @@ export class PollingClearingHouseAccountSubscriber
 		return this.orderHistory;
 	}
 }
+
+type ClearingHouseAccounts = {
+	state: PublicKey;
+	markets: PublicKey;
+	orderState: PublicKey;
+	tradeHistory?: PublicKey;
+	depositHistory?: PublicKey;
+	fundingPaymentHistory?: PublicKey;
+	fundingRateHistory?: PublicKey;
+	extendedCurveHistory?: PublicKey;
+	liquidationHistory?: PublicKey;
+	orderHistory?: PublicKey;
+};

package/src/clearingHouse.ts

@@ -543,19 +543,6 @@ export class ClearingHouse {
 		return [txSig, userAccountPublicKey];
 	}
 
-	public async deleteUser(): Promise<TransactionSignature> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const user = await this.program.account.user.fetch(userAccountPublicKey);
-		const deleteUserTx = await this.program.transaction.deleteUser({
-			accounts: {
-				user: userAccountPublicKey,
-				userPositions: user.positions,
-				authority: this.wallet.publicKey,
-			},
-		});
-		return this.txSender.send(deleteUserTx, [], this.opts);
-	}
-
 	public async withdrawCollateral(
 		amount: BN,
 		collateralAccountPublicKey: PublicKey

package/src/constants/accounts.ts

@@ -0,0 +1,26 @@
+import { PublicKey } from '@solana/web3.js';
+
+export const CLEARING_HOUSE_STATE_ACCOUNTS = {
+	dammHkt7jmytvbS3nHTxQNEcP59aE57nxwV21YdqEDN: {
+		state: new PublicKey('FExhvPycCCwYnZGeDsVtLhpEQ3yEkVY2k1HuPyfLj91L'),
+		markets: new PublicKey('773hq3SbGPKVj93TXi5qV5CREuhxobywfALjS3XVHhLH'),
+		orderState: new PublicKey('4cC34bWwTPGncBaX2S6v5mH3Lj4Nb3byPMrxQSDcY985'),
+		tradeHistory: new PublicKey('FCuCXEoQppoaCYdttA7rK3HNQfYkTNEGpwuBESzYcENp'),
+		depositHistory: new PublicKey(
+			'C7rF2Qy2rnDGQLRijBRRArJyaeuQcFi81BXDrUCQ45ya'
+		),
+		fundingPaymentHistory: new PublicKey(
+			'895iPhzwT2tBufLnRpYtBG3gif1HDDUfpH2AqbS5joo4'
+		),
+		fundingRateHistory: new PublicKey(
+			'BWiJLMbmrwfqHVpcPJa8715XamNyNYamDDKQVQMnduEC'
+		),
+		extendedCurveHistory: new PublicKey(
+			'7vBbqvMdtZLQdTVdzt5y63pZdAFE5W42kP3avngSJKCk'
+		),
+		liquidationHistory: new PublicKey(
+			'CSFaaf8yVoTx6NcXUKtNPYAewv76CH2jATqSVRBvUWKM'
+		),
+		orderHistory: new PublicKey('DZ7XfUqyHoRKnJLRApxmJ943xHJ7NDBUTqpbooviEtbU'),
+	},
+};

package/src/constants/markets.ts

@@ -198,12 +198,15 @@ export const Markets: MarketConfig[] = [
 		launchTs: 1649105516000,
 		oracleSource: OracleSource.PYTH,
 	},
-	// {
-	// 	symbol: 'mSOL-PERP',
-	// 	baseAssetSymbol: 'mSOL',
-	// 	marketIndex: new BN(11), //todo
-	// 	devnetPythOracle: '9a6RNx3tCu1TSs6TBSfV2XRXEPEZXQ6WB7jRojZRvyeZ',
-	// 	mainnetPythOracle: 'E4v1BBgoso9s64TQvmyownAVJbhbEPGyzA3qn4n46qj9',
-	// 	launchTs: 1643346125000,
-	// },
+	{
+		fullName: 'Serum',
+		category: ['DEX'],
+		symbol: 'SRM-PERP',
+		baseAssetSymbol: 'SRM',
+		marketIndex: new BN(17),
+		devnetPublicKey: '992moaMQKs32GKZ9dxi8keyM2bUmbrwBZpK4p2K6X5Vs',
+		mainnetPublicKey: '3NBReDRTLKMQEKiLD5tGcx4kXbTf88b7f2xLS9UuGjym',
+		launchTs: 1649877367000,
+		oracleSource: OracleSource.PYTH,
+	},
 ];