@drift-labs/sdk 0.2.0-master.11 → 0.2.0-master.12

package/src/clearingHouseUser.ts

@@ -21,6 +21,7 @@ import {
 	PRICE_TO_QUOTE_PRECISION,
 	MARGIN_PRECISION,
 	BANK_WEIGHT_PRECISION,
+	BANK_BALANCE_PRECISION_EXP,
 } from './constants/numericConstants';
 import {
 	UserAccountSubscriber,
@@ -32,12 +33,22 @@ import {
 	calculateBaseAssetValue,
 	calculatePositionFundingPNL,
 	calculatePositionPNL,
+	calculateUnsettledAssetWeight,
+	calculateMarketMarginRatio,
 	PositionDirection,
 	calculateTradeSlippage,
 	BN,
 	BankAccount,
 } from '.';
-import { getTokenAmount } from './math/bankBalance';
+import {
+	getTokenAmount,
+	calculateAssetWeight,
+	calculateLiabilityWeight,
+} from './math/bankBalance';
+import {
+	calculateMarginBaseAssetValue,
+	calculateWorstCaseBaseAssetAmount,
+} from './math/margin';
 import { OraclePriceData } from './oracles/types';
 import { ClearingHouseUserConfig } from './clearingHouseUserConfig';
 import { PollingUserAccountSubscriber } from './accounts/pollingUserAccountSubscriber';
@@ -124,7 +135,6 @@ export class ClearingHouseUser {
 			quoteAssetAmount: ZERO,
 			quoteEntryAmount: ZERO,
 			openOrders: ZERO,
-			unsettledPnl: ZERO,
 			openBids: ZERO,
 			openAsks: ZERO,
 		};
@@ -184,26 +194,43 @@ export class ClearingHouseUser {
 	}
 
 	public getInitialMarginRequirement(): BN {
-		return this.getUserAccount()
-			.positions.reduce((marginRequirement, marketPosition) => {
+		const postionMarginRequirement = this.getUserAccount().positions.reduce(
+			(marginRequirement, marketPosition) => {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
-				return marginRequirement.add(
-					calculateBaseAssetValue(
+				const worstCaseBaseAssetAmount =
+					calculateWorstCaseBaseAssetAmount(marketPosition);
+
+				const worstCaseAssetValue = worstCaseBaseAssetAmount
+					.abs()
+					.mul(this.getOracleDataForMarket(market.marketIndex).price)
+					.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+
+				const marketMarginRatio = new BN(
+					calculateMarketMarginRatio(
 						market,
-						marketPosition,
-						this.getOracleDataForMarket(market.marketIndex)
+						worstCaseBaseAssetAmount.abs(),
+						'Initial'
 					)
-						.mul(new BN(market.marginRatioInitial))
-						.div(MARGIN_PRECISION)
 				);
-			}, ZERO)
-			.add(this.getTotalLiability());
+				return marginRequirement.add(
+					worstCaseAssetValue.mul(marketMarginRatio).div(MARGIN_PRECISION)
+				);
+			},
+			ZERO
+		);
+
+		const bankMarginRequirement = this.getBankLiabilityValue(
+			undefined,
+			'Initial'
+		);
+
+		return bankMarginRequirement.add(postionMarginRequirement);
 	}
 
 	/**
-	 * @returns The partial margin requirement in USDC. : QUOTE_PRECISION
+	 * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
 	 */
 	public getMaintenanceMarginRequirement(): BN {
 		return this.getUserAccount()
@@ -211,24 +238,40 @@ export class ClearingHouseUser {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
+				const worstCaseBaseAssetAmount =
+					calculateWorstCaseBaseAssetAmount(marketPosition);
+
+				const worstCaseAssetValue = worstCaseBaseAssetAmount
+					.abs()
+					.mul(this.getOracleDataForMarket(market.marketIndex).price)
+					.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+
 				return marginRequirement.add(
-					calculateBaseAssetValue(
-						market,
-						marketPosition,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
-						.mul(new BN(market.marginRatioMaintenance))
+					worstCaseAssetValue
+						.mul(
+							new BN(
+								calculateMarketMarginRatio(
+									market,
+									worstCaseBaseAssetAmount.abs(),
+									'Maintenance'
+								)
+							)
+						)
 						.div(MARGIN_PRECISION)
 				);
 			}, ZERO)
-			.add(this.getTotalLiability());
+			.add(this.getBankLiabilityValue(undefined, 'Maintenance'));
 	}
 
 	/**
 	 * calculates unrealized position price pnl
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getUnrealizedPNL(withFunding?: boolean, marketIndex?: BN): BN {
+	public getUnrealizedPNL(
+		withFunding?: boolean,
+		marketIndex?: BN,
+		withWeightMarginCategory?: MarginCategory
+	): BN {
 		return this.getUserAccount()
 			.positions.filter((pos) =>
 				marketIndex ? pos.marketIndex === marketIndex : true
@@ -237,28 +280,28 @@ export class ClearingHouseUser {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
-				return pnl.add(
-					calculatePositionPNL(
-						market,
-						marketPosition,
-						withFunding,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
+				let pnl0 = calculatePositionPNL(
+					market,
+					marketPosition,
+					withFunding,
+					this.getOracleDataForMarket(market.marketIndex)
 				);
-			}, ZERO);
-	}
 
-	/**
-	 * calculates unrealized position price pnl
-	 * @returns : Precision QUOTE_PRECISION
-	 */
-	public getUnsettledPNL(marketIndex?: BN): BN {
-		return this.getUserAccount()
-			.positions.filter((pos) =>
-				marketIndex ? pos.marketIndex === marketIndex : true
-			)
-			.reduce((pnl, marketPosition) => {
-				return pnl.add(marketPosition.unsettledPnl);
+				if (withWeightMarginCategory !== undefined) {
+					if (pnl0.gt(ZERO)) {
+						pnl0 = pnl0
+							.mul(
+								calculateUnsettledAssetWeight(
+									market,
+									pnl0,
+									withWeightMarginCategory
+								)
+							)
+							.div(new BN(BANK_WEIGHT_PRECISION));
+					}
+				}
+
+				return pnl.add(pnl0);
 			}, ZERO);
 	}
 
@@ -279,14 +322,18 @@ export class ClearingHouseUser {
 			}, ZERO);
 	}
 
-	public getTotalLiability(): BN {
+	public getBankLiabilityValue(
+		bankIndex?: BN,
+		withWeightMarginCategory?: MarginCategory
+	): BN {
 		return this.getUserAccount().bankBalances.reduce(
-			(totalAssetValue, bankBalance) => {
+			(totalLiabilityValue, bankBalance) => {
 				if (
 					bankBalance.balance.eq(ZERO) ||
-					isVariant(bankBalance.balanceType, 'deposit')
+					isVariant(bankBalance.balanceType, 'deposit') ||
+					(bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))
 				) {
-					return totalAssetValue;
+					return totalLiabilityValue;
 				}
 
 				// Todo this needs to account for whether it's based on initial or maintenance requirements
@@ -299,23 +346,42 @@ export class ClearingHouseUser {
 					bankAccount,
 					bankBalance.balanceType
 				);
-				return totalAssetValue.add(
-					tokenAmount
-						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-						.mul(bankAccount.initialLiabilityWeight)
-						.div(BANK_WEIGHT_PRECISION)
-						.div(MARK_PRICE_PRECISION)
-				);
+
+				let liabilityValue = tokenAmount
+					.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
+					.div(MARK_PRICE_PRECISION)
+					.div(
+						new BN(10).pow(
+							new BN(bankAccount.decimals).sub(BANK_BALANCE_PRECISION_EXP)
+						)
+					);
+
+				if (withWeightMarginCategory !== undefined) {
+					const weight = calculateLiabilityWeight(
+						tokenAmount,
+						bankAccount,
+						withWeightMarginCategory
+					);
+					liabilityValue = liabilityValue
+						.mul(weight)
+						.div(BANK_WEIGHT_PRECISION);
+				}
+
+				return totalLiabilityValue.add(liabilityValue);
 			},
 			ZERO
 		);
 	}
 
-	public getCollateralValue(bankIndex?: BN): BN {
+	public getBankAssetValue(
+		bankIndex?: BN,
+		withWeightMarginCategory?: MarginCategory
+	): BN {
 		return this.getUserAccount().bankBalances.reduce(
 			(totalAssetValue, bankBalance) => {
 				if (
 					bankBalance.balance.eq(ZERO) ||
+					isVariant(bankBalance.balanceType, 'borrow') ||
 					(bankIndex !== undefined && !bankBalance.bankIndex.eq(bankIndex))
 				) {
 					return totalAssetValue;
@@ -326,32 +392,46 @@ export class ClearingHouseUser {
 					bankBalance.bankIndex
 				);
 
-				let tokenAmount = getTokenAmount(
+				const tokenAmount = getTokenAmount(
 					bankBalance.balance,
 					bankAccount,
 					bankBalance.balanceType
 				);
 
-				if (isVariant(bankBalance.balanceType, 'borrow')) {
-					tokenAmount = tokenAmount.mul(new BN(-1));
+				let assetValue = tokenAmount
+					.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
+					.div(MARK_PRICE_PRECISION)
+					.div(
+						new BN(10).pow(
+							new BN(bankAccount.decimals).sub(BANK_BALANCE_PRECISION_EXP)
+						)
+					);
+				if (withWeightMarginCategory !== undefined) {
+					const weight = calculateAssetWeight(
+						tokenAmount,
+						bankAccount,
+						withWeightMarginCategory
+					);
+					assetValue = assetValue.mul(weight).div(BANK_WEIGHT_PRECISION);
 				}
 
-				return totalAssetValue.add(
-					tokenAmount
-						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-						.div(MARK_PRICE_PRECISION)
-				);
+				return totalAssetValue.add(assetValue);
 			},
 			ZERO
 		);
 	}
 
+	public getNetBankValue(withWeightMarginCategory?: MarginCategory): BN {
+		return this.getBankAssetValue(undefined, withWeightMarginCategory).sub(
+			this.getBankLiabilityValue(undefined, withWeightMarginCategory)
+		);
+	}
+
 	/**
 	 * calculates TotalCollateral: collateral + unrealized pnl
-	 * TODO: rename to total equity (for perpetuals swaps)
 	 * @returns : Precision QUOTE_PRECISION
 	 */
-	public getTotalCollateral(): BN {
+	public getTotalCollateral(marginCategory: MarginCategory = 'Initial'): BN {
 		return this.getUserAccount()
 			.bankBalances.reduce((totalAssetValue, bankBalance) => {
 				if (
@@ -371,20 +451,32 @@ export class ClearingHouseUser {
 					bankAccount,
 					bankBalance.balanceType
 				);
+
+				const weight = calculateAssetWeight(
+					tokenAmount,
+					bankAccount,
+					marginCategory
+				);
+
 				return totalAssetValue.add(
 					tokenAmount
 						.mul(this.getOracleDataForBank(bankAccount.bankIndex).price)
-						.mul(bankAccount.initialAssetWeight)
+						.mul(weight)
 						.div(BANK_WEIGHT_PRECISION)
 						.div(MARK_PRICE_PRECISION)
+						// Adjust for decimals of bank account
+						.div(
+							new BN(10).pow(
+								new BN(bankAccount.decimals).sub(BANK_BALANCE_PRECISION_EXP)
+							)
+						)
 				);
 			}, ZERO)
-			.add(this.getUnrealizedPNL(true))
-			.add(this.getUnsettledPNL());
+			.add(this.getUnrealizedPNL(true, undefined, marginCategory));
 	}
 
 	/**
-	 * calculates sum of position value across all positions
+	 * calculates sum of position value across all positions in margin system
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	getTotalPositionValue(): BN {
@@ -393,20 +485,20 @@ export class ClearingHouseUser {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
-				return positionValue.add(
-					calculateBaseAssetValue(
-						market,
-						marketPosition,
-						this.getOracleDataForMarket(market.marketIndex)
-					)
+				const posVal = calculateMarginBaseAssetValue(
+					market,
+					marketPosition,
+					this.getOracleDataForMarket(market.marketIndex)
 				);
+
+				return positionValue.add(posVal);
 			},
 			ZERO
 		);
 	}
 
 	/**
-	 * calculates position value from closing 100%
+	 * calculates position value in margin system
 	 * @returns : Precision QUOTE_PRECISION
 	 */
 	public getPositionValue(
@@ -418,7 +510,7 @@ export class ClearingHouseUser {
 		const market = this.clearingHouse.getMarketAccount(
 			userPosition.marketIndex
 		);
-		return calculateBaseAssetValue(market, userPosition, oraclePriceData);
+		return calculateMarginBaseAssetValue(market, userPosition, oraclePriceData);
 	}
 
 	public getPositionSide(
@@ -434,12 +526,13 @@ export class ClearingHouseUser {
 	}
 
 	/**
-	 * calculates average exit price for closing 100% of position
+	 * calculates average exit price (optionally for closing up to 100% of position)
 	 * @returns : Precision MARK_PRICE_PRECISION
 	 */
 	public getPositionEstimatedExitPriceAndPnl(
 		position: UserPosition,
-		amountToClose?: BN
+		amountToClose?: BN,
+		useAMMClose = false
 	): [BN, BN] {
 		const market = this.clearingHouse.getMarketAccount(position.marketIndex);
 
@@ -459,11 +552,21 @@ export class ClearingHouseUser {
 			} as UserPosition;
 		}
 
-		const baseAssetValue = calculateBaseAssetValue(
-			market,
-			position,
-			oraclePriceData
-		);
+		let baseAssetValue: BN;
+
+		if (useAMMClose) {
+			baseAssetValue = calculateBaseAssetValue(
+				market,
+				position,
+				oraclePriceData
+			);
+		} else {
+			baseAssetValue = calculateMarginBaseAssetValue(
+				market,
+				position,
+				oraclePriceData
+			);
+		}
 		if (position.baseAssetAmount.eq(ZERO)) {
 			return [ZERO, ZERO];
 		}
@@ -505,19 +608,13 @@ export class ClearingHouseUser {
 		category: MarginCategory = 'Initial'
 	): BN {
 		const market = this.clearingHouse.getMarketAccount(marketIndex);
-		let marginRatioCategory: number;
-
-		switch (category) {
-			case 'Initial':
-				marginRatioCategory = market.marginRatioInitial;
-				break;
-			case 'Maintenance':
-				marginRatioCategory = market.marginRatioMaintenance;
-				break;
-			default:
-				marginRatioCategory = market.marginRatioInitial;
-				break;
-		}
+
+		const marginRatioCategory = calculateMarketMarginRatio(
+			market,
+			// worstCaseBaseAssetAmount.abs(),
+			ZERO, // todo
+			category
+		);
 		const maxLeverage = TEN_THOUSAND.mul(TEN_THOUSAND).div(
 			new BN(marginRatioCategory)
 		);
@@ -624,7 +721,6 @@ export class ClearingHouseUser {
 			quoteAssetAmount: new BN(0),
 			quoteEntryAmount: new BN(0),
 			openOrders: new BN(0),
-			unsettledPnl: new BN(0),
 			openBids: new BN(0),
 			openAsks: new BN(0),
 		};
@@ -635,7 +731,7 @@ export class ClearingHouseUser {
 			proposedMarketPosition.marketIndex
 		);
 
-		const proposedMarketPositionValue = calculateBaseAssetValue(
+		const proposedMarketPositionValue = calculateMarginBaseAssetValue(
 			market,
 			proposedMarketPosition,
 			this.getOracleDataForMarket(market.marketIndex)
@@ -652,14 +748,19 @@ export class ClearingHouseUser {
 						const market = this.clearingHouse.getMarketAccount(
 							position.marketIndex
 						);
-						const positionValue = calculateBaseAssetValue(
+						const positionValue = calculateMarginBaseAssetValue(
 							market,
 							position,
 							this.getOracleDataForMarket(market.marketIndex)
 						);
-						const marketMarginRequirement = positionValue
-							.mul(new BN(market.marginRatioMaintenance))
-							.div(MARGIN_PRECISION);
+						const marketMarginRequirement = positionValue;
+						new BN(
+							calculateMarketMarginRatio(
+								market,
+								position.baseAssetAmount.abs(),
+								'Maintenance'
+							)
+						).div(MARGIN_PRECISION);
 						totalMarginRequirement = totalMarginRequirement.add(
 							marketMarginRequirement
 						);
@@ -684,7 +785,15 @@ export class ClearingHouseUser {
 		const marginRequirementAfterTrade =
 			marginRequirementExcludingTargetMarket.add(
 				proposedMarketPositionValue
-					.mul(new BN(market.marginRatioMaintenance))
+					.mul(
+						new BN(
+							calculateMarketMarginRatio(
+								market,
+								proposedMarketPosition.baseAssetAmount.abs(),
+								'Maintenance'
+							)
+						)
+					)
 					.div(MARGIN_PRECISION)
 			);
 		const freeCollateralAfterTrade = totalCollateral.sub(
@@ -755,11 +864,11 @@ export class ClearingHouseUser {
 
 		const closeBaseAmount = currentPosition.baseAssetAmount
 			.mul(closeQuoteAmount)
-			.div(currentPosition.quoteAssetAmount)
+			.div(currentPosition.quoteAssetAmount.abs())
 			.add(
 				currentPosition.baseAssetAmount
 					.mul(closeQuoteAmount)
-					.mod(currentPosition.quoteAssetAmount)
+					.mod(currentPosition.quoteAssetAmount.abs())
 			)
 			.neg();
 

package/src/clearingHouseUserConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/config.ts

@@ -28,7 +28,7 @@ export const configs: { [key in DriftEnv]: DriftConfig } = {
 	devnet: {
 		ENV: 'devnet',
 		PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-		CLEARING_HOUSE_PROGRAM_ID: '4oyTJnAQ9FqJj1y9mPytbWsLeeHmBzGYfuFqypwyQvuh',
+		CLEARING_HOUSE_PROGRAM_ID: '7HDuhZ94TVTWpH3vba3dJhGWyHvQuy2zBjniRxE7PU88',
 		USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
 		MARKETS: DevnetMarkets,
 		BANKS: DevnetBanks,

package/src/constants/banks.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Banks = exports.MainnetBanks = exports.DevnetBanks = exports.WRAPPED_SOL_MINT = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const __1 = require("../");
+exports.WRAPPED_SOL_MINT = new web3_js_1.PublicKey('So11111111111111111111111111111111111111112');
+exports.DevnetBanks = [
+    {
+        symbol: 'USDC',
+        bankIndex: new __1.BN(0),
+        oracle: web3_js_1.PublicKey.default,
+        oracleSource: __1.OracleSource.QUOTE_ASSET,
+        mint: new web3_js_1.PublicKey('8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2'),
+    },
+    {
+        symbol: 'SOL',
+        bankIndex: new __1.BN(1),
+        oracle: new web3_js_1.PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
+        oracleSource: __1.OracleSource.PYTH,
+        mint: new web3_js_1.PublicKey(exports.WRAPPED_SOL_MINT),
+    },
+    {
+        symbol: 'BTC',
+        bankIndex: new __1.BN(2),
+        oracle: new web3_js_1.PublicKey('HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J'),
+        oracleSource: __1.OracleSource.PYTH,
+        mint: new web3_js_1.PublicKey('3BZPwbcqB5kKScF3TEXxwNfx5ipV13kbRVDvfVp5c6fv'),
+    },
+];
+exports.MainnetBanks = [
+    {
+        symbol: 'USDC',
+        bankIndex: new __1.BN(0),
+        oracle: web3_js_1.PublicKey.default,
+        oracleSource: __1.OracleSource.QUOTE_ASSET,
+        mint: new web3_js_1.PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
+    },
+];
+exports.Banks = {
+    devnet: exports.DevnetBanks,
+    'mainnet-beta': exports.MainnetBanks,
+};

package/src/constants/banks.ts

@@ -1,6 +1,5 @@
-import { BN, OracleSource } from '../';
-import { DriftEnv } from '../';
 import { PublicKey } from '@solana/web3.js';
+import { BN, DriftEnv, OracleSource } from '../';
 
 export type BankConfig = {
 	symbol: string;
@@ -10,6 +9,10 @@ export type BankConfig = {
 	oracleSource: OracleSource;
 };
 
+export const WRAPPED_SOL_MINT = new PublicKey(
+	'So11111111111111111111111111111111111111112'
+);
+
 export const DevnetBanks: BankConfig[] = [
 	{
 		symbol: 'USDC',
@@ -23,7 +26,7 @@ export const DevnetBanks: BankConfig[] = [
 		bankIndex: new BN(1),
 		oracle: new PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
 		oracleSource: OracleSource.PYTH,
-		mint: new PublicKey('So11111111111111111111111111111111111111112'),
+		mint: new PublicKey(WRAPPED_SOL_MINT),
 	},
 	{
 		symbol: 'BTC',

package/src/constants/markets.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Markets = exports.MainnetMarkets = exports.DevnetMarkets = void 0;
+const __1 = require("../");
+const web3_js_1 = require("@solana/web3.js");
+exports.DevnetMarkets = [
+    {
+        fullName: 'Solana',
+        category: ['L1', 'Infra'],
+        symbol: 'SOL-PERP',
+        baseAssetSymbol: 'SOL',
+        marketIndex: new __1.BN(0),
+        oracle: new web3_js_1.PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
+        launchTs: 1655751353000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
+    {
+        fullName: 'Bitcoin',
+        category: ['L1', 'Payment'],
+        symbol: 'BTC-PERP',
+        baseAssetSymbol: 'BTC',
+        marketIndex: new __1.BN(1),
+        oracle: new web3_js_1.PublicKey('HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J'),
+        launchTs: 1655751353000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
+    {
+        fullName: 'Ethereum',
+        category: ['L1', 'Infra'],
+        symbol: 'ETH-PERP',
+        baseAssetSymbol: 'ETH',
+        marketIndex: new __1.BN(2),
+        oracle: new web3_js_1.PublicKey('EdVCmQ9FSPcVe5YySXDPCRmc8aDQLKJ9xvYBMZPie1Vw'),
+        launchTs: 1637691133472,
+        oracleSource: __1.OracleSource.PYTH,
+    },
+];
+exports.MainnetMarkets = [];
+exports.Markets = {
+    devnet: exports.DevnetMarkets,
+    'mainnet-beta': [],
+};