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

package/src/orders.ts

@@ -1,177 +1,9 @@
-import {
-	isVariant,
-	MarketAccount,
-	Order,
-	PositionDirection,
-	SwapDirection,
-	UserAccount,
-	UserPosition,
-} from './types';
-import {
-	BN,
-	calculateAmmReservesAfterSwap,
-	calculateBaseAssetValue,
-	calculateSpreadReserves,
-	ClearingHouseUser,
-	isOrderRiskIncreasingInSameDirection,
-	standardizeBaseAssetAmount,
-	TEN_THOUSAND,
-} from '.';
-import {
-	calculateMarkPrice,
-	calculateNewMarketAfterTrade,
-} from './math/market';
-import {
-	AMM_TO_QUOTE_PRECISION_RATIO,
-	TWO,
-	PEG_PRECISION,
-	ZERO,
-} from './constants/numericConstants';
+import { isVariant, MarketAccount, Order, PositionDirection } from './types';
+import { BN, standardizeBaseAssetAmount } from '.';
+import { ZERO } from './constants/numericConstants';
 import { calculateMaxBaseAssetAmountToTrade } from './math/amm';
-import {
-	findDirectionToClose,
-	positionCurrentDirection,
-} from './math/position';
 import { OraclePriceData } from '.';
 
-export function calculateNewStateAfterOrder(
-	userAccount: UserAccount,
-	userPosition: UserPosition,
-	market: MarketAccount,
-	order: Order
-): [UserAccount, UserPosition, MarketAccount] | null {
-	if (isVariant(order.status, 'init')) {
-		return null;
-	}
-
-	const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(
-		market,
-		order
-	);
-	if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
-		return null;
-	}
-
-	const userAccountAfter = Object.assign({}, userAccount);
-	const userPositionAfter = Object.assign({}, userPosition);
-
-	const currentPositionDirection = positionCurrentDirection(userPosition);
-	const increasePosition =
-		userPosition.baseAssetAmount.eq(ZERO) ||
-		isSameDirection(order.direction, currentPositionDirection);
-
-	if (increasePosition) {
-		const marketAfter = calculateNewMarketAfterTrade(
-			baseAssetAmountToTrade,
-			order.direction,
-			market
-		);
-
-		const { quoteAssetAmountSwapped, baseAssetAmountSwapped } =
-			calculateAmountSwapped(market, marketAfter);
-
-		userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(
-			baseAssetAmountSwapped
-		);
-		userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(
-			quoteAssetAmountSwapped
-		);
-
-		return [userAccountAfter, userPositionAfter, marketAfter];
-	} else {
-		const reversePosition = baseAssetAmountToTrade.gt(
-			userPosition.baseAssetAmount.abs()
-		);
-
-		if (reversePosition) {
-			const intermediateMarket = calculateNewMarketAfterTrade(
-				userPosition.baseAssetAmount,
-				findDirectionToClose(userPosition),
-				market
-			);
-
-			const { quoteAssetAmountSwapped: baseAssetValue } =
-				calculateAmountSwapped(market, intermediateMarket);
-
-			let pnl;
-			if (isVariant(currentPositionDirection, 'long')) {
-				pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
-			} else {
-				pnl = userPosition.quoteAssetAmount.sub(baseAssetValue);
-			}
-
-			userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-
-			const baseAssetAmountLeft = baseAssetAmountToTrade.sub(
-				userPosition.baseAssetAmount.abs()
-			);
-
-			const marketAfter = calculateNewMarketAfterTrade(
-				baseAssetAmountLeft,
-				order.direction,
-				intermediateMarket
-			);
-
-			const { quoteAssetAmountSwapped, baseAssetAmountSwapped } =
-				calculateAmountSwapped(intermediateMarket, marketAfter);
-
-			userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
-			userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
-
-			return [userAccountAfter, userPositionAfter, marketAfter];
-		} else {
-			const marketAfter = calculateNewMarketAfterTrade(
-				baseAssetAmountToTrade,
-				order.direction,
-				market
-			);
-
-			const {
-				quoteAssetAmountSwapped: baseAssetValue,
-				baseAssetAmountSwapped,
-			} = calculateAmountSwapped(market, marketAfter);
-
-			const costBasisRealized = userPosition.quoteAssetAmount
-				.mul(baseAssetAmountSwapped.abs())
-				.div(userPosition.baseAssetAmount.abs());
-
-			let pnl;
-			if (isVariant(currentPositionDirection, 'long')) {
-				pnl = baseAssetValue.sub(costBasisRealized);
-			} else {
-				pnl = costBasisRealized.sub(baseAssetValue);
-			}
-
-			userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-
-			userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(
-				baseAssetAmountSwapped
-			);
-			userPositionAfter.quoteAssetAmount =
-				userPositionAfter.quoteAssetAmount.sub(costBasisRealized);
-
-			return [userAccountAfter, userPositionAfter, marketAfter];
-		}
-	}
-}
-
-function calculateAmountSwapped(
-	marketBefore: MarketAccount,
-	marketAfter: MarketAccount
-): { quoteAssetAmountSwapped: BN; baseAssetAmountSwapped: BN } {
-	return {
-		quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
-			.sub(marketAfter.amm.quoteAssetReserve)
-			.abs()
-			.mul(marketBefore.amm.pegMultiplier)
-			.div(PEG_PRECISION)
-			.div(AMM_TO_QUOTE_PRECISION_RATIO),
-		baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(
-			marketAfter.amm.baseAssetReserve
-		),
-	};
-}
-
 export function calculateBaseAssetAmountMarketCanExecute(
 	market: MarketAccount,
 	order: Order,
@@ -182,7 +14,6 @@ export function calculateBaseAssetAmountMarketCanExecute(
 	} else if (isVariant(order.orderType, 'triggerLimit')) {
 		return calculateAmountToTradeForTriggerLimit(market, order);
 	} else if (isVariant(order.orderType, 'market')) {
-		// should never be a market order queued
 		return ZERO;
 	} else {
 		return calculateAmountToTradeForTriggerMarket(market, order);
@@ -201,20 +32,14 @@ export function calculateAmountToTradeForLimit(
 				'Cant calculate limit price for oracle offset oracle without OraclePriceData'
 			);
 		}
-		const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-		if (order.postOnly) {
-			limitPrice = isVariant(order.direction, 'long')
-				? BN.min(order.price, floatingPrice)
-				: BN.max(order.price, floatingPrice);
-		} else {
-			limitPrice = floatingPrice;
-		}
+		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
 	}
 
 	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
 		market.amm,
 		limitPrice,
-		order.direction
+		order.direction,
+		oraclePriceData
 	);
 
 	const baseAssetAmount = standardizeBaseAssetAmount(
@@ -237,14 +62,8 @@ export function calculateAmountToTradeForTriggerLimit(
 	market: MarketAccount,
 	order: Order
 ): BN {
-	if (order.baseAssetAmountFilled.eq(ZERO)) {
-		const baseAssetAmount = calculateAmountToTradeForTriggerMarket(
-			market,
-			order
-		);
-		if (baseAssetAmount.eq(ZERO)) {
-			return ZERO;
-		}
+	if (!order.triggered) {
+		return ZERO;
 	}
 
 	return calculateAmountToTradeForLimit(market, order);
@@ -264,105 +83,9 @@ function calculateAmountToTradeForTriggerMarket(
 	market: MarketAccount,
 	order: Order
 ): BN {
-	return isTriggerConditionSatisfied(market, order)
-		? order.baseAssetAmount
-		: ZERO;
-}
-
-function isTriggerConditionSatisfied(
-	market: MarketAccount,
-	order: Order,
-	oraclePriceData?: OraclePriceData
-): boolean {
-	const markPrice = calculateMarkPrice(market, oraclePriceData);
-	if (isVariant(order.triggerCondition, 'above')) {
-		return markPrice.gt(order.triggerPrice);
-	} else {
-		return markPrice.lt(order.triggerPrice);
-	}
-}
-
-export function calculateBaseAssetAmountUserCanExecute(
-	market: MarketAccount,
-	order: Order,
-	user: ClearingHouseUser,
-	oraclePriceData?: OraclePriceData
-): BN {
-	const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
-	const freeCollateral = user.getFreeCollateral();
-	let quoteAssetAmount: BN;
-	if (isOrderRiskIncreasingInSameDirection(user, order)) {
-		quoteAssetAmount = freeCollateral.mul(maxLeverage).div(TEN_THOUSAND);
-	} else {
-		const position =
-			user.getUserPosition(order.marketIndex) ||
-			user.getEmptyPosition(order.marketIndex);
-		const positionValue = calculateBaseAssetValue(
-			market,
-			position,
-			oraclePriceData
-		);
-		quoteAssetAmount = freeCollateral
-			.mul(maxLeverage)
-			.div(TEN_THOUSAND)
-			.add(positionValue.mul(TWO));
-	}
-
-	if (quoteAssetAmount.lte(ZERO)) {
+	if (!order.triggered) {
 		return ZERO;
 	}
 
-	const swapDirection = isVariant(order.direction, 'long')
-		? SwapDirection.ADD
-		: SwapDirection.REMOVE;
-
-	const useSpread = !order.postOnly;
-	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
-	if (useSpread) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			order.direction,
-			oraclePriceData
-		);
-		amm = {
-			baseAssetReserve,
-			quoteAssetReserve,
-			sqrtK: market.amm.sqrtK,
-			pegMultiplier: market.amm.pegMultiplier,
-		};
-	} else {
-		amm = market.amm;
-	}
-
-	const baseAssetReservesBefore = amm.baseAssetReserve;
-	const [_, baseAssetReservesAfter] = calculateAmmReservesAfterSwap(
-		amm,
-		'quote',
-		quoteAssetAmount,
-		swapDirection
-	);
-
-	let baseAssetAmount = baseAssetReservesBefore
-		.sub(baseAssetReservesAfter)
-		.abs();
-	if (order.reduceOnly) {
-		const position =
-			user.getUserPosition(order.marketIndex) ||
-			user.getEmptyPosition(order.marketIndex);
-		if (
-			isVariant(order.direction, 'long') &&
-			position.baseAssetAmount.gte(ZERO)
-		) {
-			baseAssetAmount = ZERO;
-		} else if (
-			isVariant(order.direction, 'short') &&
-			position.baseAssetAmount.lte(ZERO)
-		) {
-			baseAssetAmount = ZERO;
-		} else {
-			BN.min(baseAssetAmount, position.baseAssetAmount.abs());
-		}
-	}
-
-	return baseAssetAmount;
+	return order.baseAssetAmount;
 }

package/src/slot/SlotSubscriber.js

@@ -0,0 +1,39 @@
+"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.SlotSubscriber = void 0;
+const events_1 = require("events");
+class SlotSubscriber {
+    constructor(connection, _config) {
+        this.connection = connection;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.currentSlot = yield this.connection.getSlot('confirmed');
+            this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
+                this.currentSlot = slotInfo.slot;
+                this.eventEmitter.emit('newSlot', slotInfo.slot);
+            });
+        });
+    }
+    getSlot() {
+        return this.currentSlot;
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.subscriptionId) {
+                yield this.connection.removeSlotChangeListener(this.subscriptionId);
+            }
+        });
+    }
+}
+exports.SlotSubscriber = SlotSubscriber;

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;

package/src/tokenFaucet.js

@@ -0,0 +1,189 @@
+"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.TokenFaucet = 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 token_faucet_json_1 = __importDefault(require("./idl/token_faucet.json"));
+class TokenFaucet {
+    constructor(connection, wallet, programId, mint, opts) {
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts || anchor_1.AnchorProvider.defaultOptions();
+        const provider = new anchor_1.AnchorProvider(connection, wallet, this.opts);
+        this.provider = provider;
+        this.program = new anchor_1.Program(token_faucet_json_1.default, programId, provider);
+        this.mint = mint;
+    }
+    getFaucetConfigPublicKeyAndNonce() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return anchor.web3.PublicKey.findProgramAddress([
+                Buffer.from(anchor.utils.bytes.utf8.encode('faucet_config')),
+                this.mint.toBuffer(),
+            ], this.program.programId);
+        });
+    }
+    getMintAuthority() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield anchor.web3.PublicKey.findProgramAddress([
+                Buffer.from(anchor.utils.bytes.utf8.encode('mint_authority')),
+                this.mint.toBuffer(),
+            ], this.program.programId))[0];
+        });
+    }
+    getFaucetConfigPublicKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getFaucetConfigPublicKeyAndNonce())[0];
+        });
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [faucetConfigPublicKey] = yield this.getFaucetConfigPublicKeyAndNonce();
+            return yield this.program.rpc.initialize({
+                accounts: {
+                    faucetConfig: faucetConfigPublicKey,
+                    admin: this.wallet.publicKey,
+                    mintAccount: this.mint,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: anchor.web3.SystemProgram.programId,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    fetchState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.account.faucetConfig.fetch(yield this.getFaucetConfigPublicKey());
+        });
+    }
+    mintToUserIx(userTokenAccount, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.program.instruction.mintToUser(amount, {
+                accounts: {
+                    faucetConfig: yield this.getFaucetConfigPublicKey(),
+                    mintAccount: this.mint,
+                    userTokenAccount,
+                    mintAuthority: yield this.getMintAuthority(),
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    mintToUser(userTokenAccount, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mintIx = yield this.mintToUserIx(userTokenAccount, amount);
+            const tx = new web3_js_1.Transaction().add(mintIx);
+            const txSig = yield this.program.provider.sendAndConfirm(tx, [], this.opts);
+            return txSig;
+        });
+    }
+    transferMintAuthority() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.transferMintAuthority({
+                accounts: {
+                    faucetConfig: yield this.getFaucetConfigPublicKey(),
+                    mintAccount: this.mint,
+                    mintAuthority: yield this.getMintAuthority(),
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    admin: this.wallet.publicKey,
+                },
+            });
+        });
+    }
+    createAssociatedTokenAccountAndMintTo(userPublicKey, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tx = new web3_js_1.Transaction();
+            const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] = yield this.createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount);
+            let associatedTokenAccountExists = false;
+            try {
+                const assosciatedTokenAccount = yield this.connection.getAccountInfo(associatedTokenPublicKey);
+                associatedTokenAccountExists = !!assosciatedTokenAccount;
+            }
+            catch (e) {
+                // token account doesn't exist
+                associatedTokenAccountExists = false;
+            }
+            const skipAccountCreation = associatedTokenAccountExists;
+            if (!skipAccountCreation)
+                tx.add(createAssociatedAccountIx);
+            tx.add(mintToTx);
+            const txSig = yield this.program.provider.sendAndConfirm(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.mintToUserIx(associateTokenPublicKey, amount);
+            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.TokenFaucet = TokenFaucet;