@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.30

package/src/math/spotPosition.ts

@@ -0,0 +1,47 @@
+import { SpotMarketAccount, SpotPosition } from '../types';
+import { ZERO } from '../constants/numericConstants';
+import { BN } from '@project-serum/anchor';
+import {
+	getSignedTokenAmount,
+	getTokenAmount,
+	getTokenValue,
+} from './spotBalance';
+import { OraclePriceData } from '../oracles/types';
+
+export function isSpotPositionAvailable(position: SpotPosition): boolean {
+	return position.balance.eq(ZERO) && position.openOrders === 0;
+}
+
+export function getWorstCaseTokenAmounts(
+	spotPosition: SpotPosition,
+	spotMarketAccount: SpotMarketAccount,
+	oraclePriceData: OraclePriceData
+): [BN, BN] {
+	const tokenAmount = getSignedTokenAmount(
+		getTokenAmount(
+			spotPosition.balance,
+			spotMarketAccount,
+			spotPosition.balanceType
+		),
+		spotPosition.balanceType
+	);
+
+	const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
+	const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
+
+	if (tokenAmountAllAsksFill.abs().gt(tokenAmountAllBidsFill.abs())) {
+		const worstCaseQuoteTokenAmount = getTokenValue(
+			spotPosition.openAsks.neg(),
+			spotMarketAccount.decimals,
+			oraclePriceData
+		);
+		return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
+	} else {
+		const worstCaseQuoteTokenAmount = getTokenValue(
+			spotPosition.openBids.neg(),
+			spotMarketAccount.decimals,
+			oraclePriceData
+		);
+		return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
+	}
+}

package/src/math/trade.ts

@@ -1,8 +1,8 @@
-import { MarketAccount, PositionDirection, SwapDirection } from '../types';
+import { PerpMarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	PEG_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	ZERO,
@@ -10,7 +10,7 @@ import {
 import {
 	calculateBidPrice,
 	calculateAskPrice,
-	calculateMarkPrice,
+	calculateReservePrice,
 } from './market';
 import {
 	calculateAmmReservesAfterSwap,
@@ -48,18 +48,18 @@ export type PriceImpactUnit =
  * @param useSpread whether to consider spread with calculating slippage
  * @return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice]
  *
- * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'entryPrice' => the average price of the trade : Precision MARK_PRICE_PRECISION
+ * 'entryPrice' => the average price of the trade : Precision PRICE_PRECISION
  *
- * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
+ * 'newPrice' => the price of the asset after the trade : Precision PRICE_PRECISION
  */
 export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	inputAssetType: AssetType = 'quote',
 	oraclePriceData?: OraclePriceData,
 	useSpread = true
@@ -73,33 +73,25 @@ export function calculateTradeSlippage(
 			oldPrice = calculateBidPrice(market, oraclePriceData);
 		}
 	} else {
-		oldPrice = calculateMarkPrice(market, oraclePriceData);
+		oldPrice = calculateReservePrice(market, oraclePriceData);
 	}
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO, oldPrice, oldPrice];
 	}
-	const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(
-		direction,
-		amount,
-		market,
-		inputAssetType,
-		oraclePriceData,
-		useSpread
-	);
-
-	const swapDirection = isVariant(direction, 'long')
-		? SwapDirection.REMOVE
-		: SwapDirection.ADD;
-	const quoteAssetAmountAcquired = calculateQuoteAssetAmountSwapped(
-		acquiredQuote.abs(),
-		market.amm.pegMultiplier,
-		swapDirection
-	);
+	const [acquiredBaseReserve, acquiredQuoteReserve, acquiredQuoteAssetAmount] =
+		calculateTradeAcquiredAmounts(
+			direction,
+			amount,
+			market,
+			inputAssetType,
+			oraclePriceData,
+			useSpread
+		);
 
-	const entryPrice = quoteAssetAmountAcquired
+	const entryPrice = acquiredQuoteAssetAmount
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
-		.mul(MARK_PRICE_PRECISION)
-		.div(acquiredBase.abs());
+		.mul(PRICE_PRECISION)
+		.div(acquiredBaseReserve.abs());
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 	if (useSpread && market.amm.baseSpread > 0) {
@@ -116,8 +108,8 @@ export function calculateTradeSlippage(
 	}
 
 	const newPrice = calculatePrice(
-		amm.baseAssetReserve.sub(acquiredBase),
-		amm.quoteAssetReserve.sub(acquiredQuote),
+		amm.baseAssetReserve.sub(acquiredBaseReserve),
+		amm.quoteAssetReserve.sub(acquiredQuoteReserve),
 		amm.pegMultiplier
 	);
 
@@ -129,12 +121,12 @@ export function calculateTradeSlippage(
 
 	const pctMaxSlippage = newPrice
 		.sub(oldPrice)
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(oldPrice)
 		.abs();
 	const pctAvgSlippage = entryPrice
 		.sub(oldPrice)
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(oldPrice)
 		.abs();
 
@@ -155,13 +147,13 @@ export function calculateTradeSlippage(
 export function calculateTradeAcquiredAmounts(
 	direction: PositionDirection,
 	amount: BN,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	inputAssetType: AssetType = 'quote',
 	oraclePriceData: OraclePriceData,
 	useSpread = true
-): [BN, BN] {
+): [BN, BN, BN] {
 	if (amount.eq(ZERO)) {
-		return [ZERO, ZERO];
+		return [ZERO, ZERO, ZERO];
 	}
 
 	const swapDirection = getSwapDirection(inputAssetType, direction);
@@ -185,7 +177,13 @@ export function calculateTradeAcquiredAmounts(
 
 	const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
 	const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-	return [acquiredBase, acquiredQuote];
+	const acquiredQuoteAssetAmount = calculateQuoteAssetAmountSwapped(
+		acquiredQuote.abs(),
+		amm.pegMultiplier,
+		swapDirection
+	);
+
+	return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
 }
 
 /**
@@ -201,12 +199,12 @@ export function calculateTradeAcquiredAmounts(
  * [
  *   direction => direction of trade required, PositionDirection
  *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, MARK_PRICE_PRECISION
- *   targetPrice => the target price MARK_PRICE_PRECISION
+ *   entryPrice => the entry price for the trade, PRICE_PRECISION
+ *   targetPrice => the target price PRICE_PRECISION
  * ]
  */
 export function calculateTargetPriceTrade(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	targetPrice: BN,
 	pct: BN = MAXPCT,
 	outputAssetType: AssetType = 'quote',
@@ -217,7 +215,7 @@ export function calculateTargetPriceTrade(
 	assert(targetPrice.gt(ZERO));
 	assert(pct.lte(MAXPCT) && pct.gt(ZERO));
 
-	const markPriceBefore = calculateMarkPrice(market, oraclePriceData);
+	const markPriceBefore = calculateReservePrice(market, oraclePriceData);
 	const bidPriceBefore = calculateBidPrice(market, oraclePriceData);
 	const askPriceBefore = calculateAskPrice(market, oraclePriceData);
 
@@ -254,7 +252,7 @@ export function calculateTargetPriceTrade(
 	}
 
 	const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
-	const k = invariant.mul(MARK_PRICE_PRECISION);
+	const k = invariant.mul(PRICE_PRECISION);
 
 	let baseAssetReserveAfter;
 	let quoteAssetReserveAfter;
@@ -279,9 +277,7 @@ export function calculateTargetPriceTrade(
 		baseAssetReserveAfter = squareRootBN(
 			k.div(targetPrice).mul(peg).div(PEG_PRECISION).sub(biasModifier)
 		).sub(new BN(1));
-		quoteAssetReserveAfter = k
-			.div(MARK_PRICE_PRECISION)
-			.div(baseAssetReserveAfter);
+		quoteAssetReserveAfter = k.div(PRICE_PRECISION).div(baseAssetReserveAfter);
 
 		markPriceAfter = calculatePrice(
 			baseAssetReserveAfter,
@@ -300,9 +296,7 @@ export function calculateTargetPriceTrade(
 		baseAssetReserveAfter = squareRootBN(
 			k.div(targetPrice).mul(peg).div(PEG_PRECISION).add(biasModifier)
 		).add(new BN(1));
-		quoteAssetReserveAfter = k
-			.div(MARK_PRICE_PRECISION)
-			.div(baseAssetReserveAfter);
+		quoteAssetReserveAfter = k.div(PRICE_PRECISION).div(baseAssetReserveAfter);
 
 		markPriceAfter = calculatePrice(
 			baseAssetReserveAfter,
@@ -336,7 +330,7 @@ export function calculateTargetPriceTrade(
 
 	const entryPrice = tradeSize
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(baseSize.abs());
 
 	assert(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');

package/src/oracles/pythClient.ts

@@ -2,7 +2,7 @@ import { parsePriceData } from '@pythnetwork/client';
 import { Connection, PublicKey } from '@solana/web3.js';
 import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
-import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
+import { PRICE_PRECISION, TEN } from '../constants/numericConstants';
 
 export class PythClient implements OracleClient {
 	private connection: Connection;
@@ -38,6 +38,6 @@ 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)
+		.mul(PRICE_PRECISION)
 		.div(pythPrecision);
 }

package/src/oracles/quoteAssetOracleClient.ts

@@ -1,10 +1,10 @@
 import { PublicKey } from '@solana/web3.js';
 import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
-import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
+import { PRICE_PRECISION } from '../constants/numericConstants';
 
 export const QUOTE_ORACLE_PRICE_DATA: OraclePriceData = {
-	price: MARK_PRICE_PRECISION,
+	price: PRICE_PRECISION,
 	slot: new BN(0),
 	confidence: new BN(1),
 	hasSufficientNumberOfDataPoints: true,

package/src/oracles/switchboardClient.ts

@@ -1,7 +1,7 @@
 import { SwitchboardDecimal } from '@switchboard-xyz/switchboard-v2';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import { BN, Program, Idl, AnchorProvider } from '@project-serum/anchor';
-import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
+import { PRICE_PRECISION, TEN } from '../constants/numericConstants';
 import { OracleClient, OraclePriceData } from './types';
 import { Wallet } from '../wallet';
 import switchboardV2Idl from '../idl/switchboard_v2.json';
@@ -74,6 +74,6 @@ function getSwitchboardProgram(connection: Connection): Program {
 function convertSwitchboardDecimal(switchboardDecimal: SwitchboardDecimal): BN {
 	const switchboardPrecision = TEN.pow(new BN(switchboardDecimal.scale));
 	return switchboardDecimal.mantissa
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(switchboardPrecision);
 }

package/src/orderParams.ts

@@ -1,154 +1,41 @@
-import {
-	OrderParams,
-	OrderTriggerCondition,
-	OrderType,
-	PositionDirection,
-} from './types';
+import { OptionalOrderParams, OrderTriggerCondition, OrderType } from './types';
 import { BN } from '@project-serum/anchor';
-import { ZERO } from './constants/numericConstants';
 
 export function getLimitOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	price: BN,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false,
-	userOrderId = 0,
-	postOnly = false,
-	oraclePriceOffset = ZERO,
-	immediateOrCancel = false
-): OrderParams {
-	return {
+	params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & { price: BN }
+): OptionalOrderParams {
+	return Object.assign({}, params, {
 		orderType: OrderType.LIMIT,
-		userOrderId,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly,
-		immediateOrCancel,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition: OrderTriggerCondition.ABOVE,
-		triggerPrice: ZERO,
-		oraclePriceOffset,
-	};
+	});
 }
 
 export function getTriggerMarketOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	triggerPrice: BN,
-	triggerCondition: OrderTriggerCondition,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false,
-	userOrderId = 0
-): OrderParams {
-	return {
+	params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
+		triggerCondition: OrderTriggerCondition;
+		triggerPrice: BN;
+	}
+): OptionalOrderParams {
+	return Object.assign({}, params, {
 		orderType: OrderType.TRIGGER_MARKET,
-		userOrderId,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price: ZERO,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition,
-		triggerPrice,
-		oraclePriceOffset: ZERO,
-	};
+	});
 }
 
 export function getTriggerLimitOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	price: BN,
-	triggerPrice: BN,
-	triggerCondition: OrderTriggerCondition,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false,
-	userOrderId = 0
-): OrderParams {
-	return {
+	params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
+		triggerCondition: OrderTriggerCondition;
+		triggerPrice: BN;
+		price: BN;
+	}
+): OptionalOrderParams {
+	return Object.assign({}, params, {
 		orderType: OrderType.TRIGGER_LIMIT,
-		userOrderId,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition,
-		triggerPrice,
-		oraclePriceOffset: ZERO,
-	};
+	});
 }
 
 export function getMarketOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	quoteAssetAmount: BN,
-	baseAssetAmount: BN,
-	reduceOnly: boolean,
-	price = ZERO,
-	discountToken = false,
-	referrer = false
-): OrderParams {
-	if (baseAssetAmount.eq(ZERO) && quoteAssetAmount.eq(ZERO)) {
-		throw Error('baseAssetAmount or quoteAssetAmount must be zero');
-	}
-
-	return {
+	params: Omit<OptionalOrderParams, 'orderType' | 'marketType'>
+): OptionalOrderParams {
+	return Object.assign({}, params, {
 		orderType: OrderType.MARKET,
-		userOrderId: 0,
-		marketIndex,
-		direction,
-		quoteAssetAmount,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition: OrderTriggerCondition.ABOVE,
-		triggerPrice: ZERO,
-		oraclePriceOffset: ZERO,
-	};
+	});
 }

package/src/serum/serumSubscriber.ts

@@ -0,0 +1,80 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import { Market, Orderbook } from '@project-serum/serum';
+import { SerumMarketSubscriberConfig } from './types';
+
+export class SerumSubscriber {
+	connection: Connection;
+	programId: PublicKey;
+	marketAddress: PublicKey;
+	accountLoader: BulkAccountLoader;
+	market: Market;
+
+	subscribed: boolean;
+
+	asksAddress: PublicKey;
+	asks: Orderbook;
+	asksCallbackId: string;
+	lastAsksSlot: number;
+
+	bidsAddress: PublicKey;
+	bids: Orderbook;
+	bidsCallbackId: string;
+	lastBidsSlot: number;
+
+	public constructor(config: SerumMarketSubscriberConfig) {
+		this.connection = config.connection;
+		this.programId = config.programId;
+		this.marketAddress = config.marketAddress;
+		this.accountLoader = config.accountSubscription.accountLoader;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.subscribed) {
+			return;
+		}
+
+		this.market = await Market.load(
+			this.connection,
+			this.marketAddress,
+			undefined,
+			this.programId
+		);
+
+		this.asksAddress = this.market.asksAddress;
+		this.asks = await this.market.loadAsks(this.connection);
+
+		this.asksCallbackId = this.accountLoader.addAccount(
+			this.asksAddress,
+			(buffer, slot) => {
+				this.lastAsksSlot = slot;
+				this.asks = Orderbook.decode(this.market, buffer);
+				console.log(this.asks.getL2(3));
+			}
+		);
+
+		this.bidsAddress = this.market.bidsAddress;
+		this.bids = await this.market.loadBids(this.connection);
+
+		this.bidsCallbackId = this.accountLoader.addAccount(
+			this.bidsAddress,
+			(buffer, slot) => {
+				this.lastBidsSlot = slot;
+				this.bids = Orderbook.decode(this.market, buffer);
+			}
+		);
+
+		this.subscribed = true;
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.subscribed) {
+			return;
+		}
+
+		this.accountLoader.removeAccount(this.asksAddress, this.asksCallbackId);
+		this.accountLoader.removeAccount(this.bidsAddress, this.bidsCallbackId);
+
+		this.subscribed = false;
+	}
+}

package/src/serum/types.ts

@@ -0,0 +1,13 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+
+export type SerumMarketSubscriberConfig = {
+	connection: Connection;
+	programId: PublicKey;
+	marketAddress: PublicKey;
+	accountSubscription: {
+		// enables use to add web sockets in the future
+		type: 'polling';
+		accountLoader: BulkAccountLoader;
+	};
+};

package/src/slot/SlotSubscriber.ts

@@ -1,22 +1,32 @@
 import { Connection } from '@solana/web3.js';
+import { EventEmitter } from 'events';
+import StrictEventEmitter from 'strict-event-emitter-types/types/src';
 
 // eslint-disable-next-line @typescript-eslint/ban-types
 type SlotSubscriberConfig = {}; // for future customization
 
+export interface SlotSubscriberEvents {
+	newSlot: (newSlot: number) => void;
+}
+
 export class SlotSubscriber {
 	currentSlot: number;
 	subscriptionId: number;
+	eventEmitter: StrictEventEmitter<EventEmitter, SlotSubscriberEvents>;
 
 	public constructor(
 		private connection: Connection,
 		_config?: SlotSubscriberConfig
-	) {}
+	) {
+		this.eventEmitter = new EventEmitter();
+	}
 
 	public async subscribe(): Promise<void> {
 		this.currentSlot = await this.connection.getSlot('confirmed');
 
 		this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
 			this.currentSlot = slotInfo.slot;
+			this.eventEmitter.emit('newSlot', slotInfo.slot);
 		});
 	}
 

package/src/token/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokenAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+function parseTokenAccount(data) {
+    const accountInfo = spl_token_1.AccountLayout.decode(data);
+    accountInfo.mint = new web3_js_1.PublicKey(accountInfo.mint);
+    accountInfo.owner = new web3_js_1.PublicKey(accountInfo.owner);
+    accountInfo.amount = spl_token_1.u64.fromBuffer(accountInfo.amount);
+    if (accountInfo.delegateOption === 0) {
+        accountInfo.delegate = null;
+        // eslint-disable-next-line new-cap
+        accountInfo.delegatedAmount = new spl_token_1.u64(0);
+    }
+    else {
+        accountInfo.delegate = new web3_js_1.PublicKey(accountInfo.delegate);
+        accountInfo.delegatedAmount = spl_token_1.u64.fromBuffer(accountInfo.delegatedAmount);
+    }
+    accountInfo.isInitialized = accountInfo.state !== 0;
+    accountInfo.isFrozen = accountInfo.state === 2;
+    if (accountInfo.isNativeOption === 1) {
+        accountInfo.rentExemptReserve = spl_token_1.u64.fromBuffer(accountInfo.isNative);
+        accountInfo.isNative = true;
+    }
+    else {
+        accountInfo.rentExemptReserve = null;
+        accountInfo.isNative = false;
+    }
+    if (accountInfo.closeAuthorityOption === 0) {
+        accountInfo.closeAuthority = null;
+    }
+    else {
+        accountInfo.closeAuthority = new web3_js_1.PublicKey(accountInfo.closeAuthority);
+    }
+    return accountInfo;
+}
+exports.parseTokenAccount = parseTokenAccount;