@drift-labs/sdk 0.2.0-temp.0 → 0.2.0-temp.1

package/src/math/trade.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateTargetPriceTrade = exports.calculateTradeAcquiredAmounts = exports.calculateTradeSlippage = void 0;
+const types_1 = require("../types");
+const anchor_1 = require("@project-serum/anchor");
+const assert_1 = require("../assert/assert");
+const numericConstants_1 = require("../constants/numericConstants");
+const market_1 = require("./market");
+const amm_1 = require("./amm");
+const utils_1 = require("./utils");
+const types_2 = require("../types");
+const MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
+/**
+ * Calculates avg/max slippage (price impact) for candidate trade
+ * @param direction
+ * @param amount
+ * @param market
+ * @param inputAssetType which asset is being traded
+ * @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
+ *
+ * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision MARK_PRICE_PRECISION
+ *
+ * 'entryPrice' => the average price of the trade : Precision MARK_PRICE_PRECISION
+ *
+ * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
+ */
+function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quote', oraclePriceData, useSpread = true) {
+    let oldPrice;
+    if (useSpread && market.amm.baseSpread > 0) {
+        if (types_2.isVariant(direction, 'long')) {
+            oldPrice = market_1.calculateAskPrice(market, oraclePriceData);
+        }
+        else {
+            oldPrice = market_1.calculateBidPrice(market, oraclePriceData);
+        }
+    }
+    else {
+        oldPrice = market_1.calculateMarkPrice(market, oraclePriceData);
+    }
+    if (amount.eq(numericConstants_1.ZERO)) {
+        return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
+    }
+    const [acquiredBaseReserve, acquiredQuoteReserve, acquiredQuoteAssetAmount] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread);
+    const entryPrice = acquiredQuoteAssetAmount
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(acquiredBaseReserve.abs());
+    let amm;
+    if (useSpread && market.amm.baseSpread > 0) {
+        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
+        amm = {
+            baseAssetReserve,
+            quoteAssetReserve,
+            sqrtK: sqrtK,
+            pegMultiplier: newPeg,
+        };
+    }
+    else {
+        amm = market.amm;
+    }
+    const newPrice = amm_1.calculatePrice(amm.baseAssetReserve.sub(acquiredBaseReserve), amm.quoteAssetReserve.sub(acquiredQuoteReserve), amm.pegMultiplier);
+    if (direction == types_1.PositionDirection.SHORT) {
+        assert_1.assert(newPrice.lte(oldPrice));
+    }
+    else {
+        assert_1.assert(oldPrice.lte(newPrice));
+    }
+    const pctMaxSlippage = newPrice
+        .sub(oldPrice)
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(oldPrice)
+        .abs();
+    const pctAvgSlippage = entryPrice
+        .sub(oldPrice)
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(oldPrice)
+        .abs();
+    return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice];
+}
+exports.calculateTradeSlippage = calculateTradeSlippage;
+/**
+ * Calculates acquired amounts for trade executed
+ * @param direction
+ * @param amount
+ * @param market
+ * @param inputAssetType
+ * @param useSpread
+ * @return
+ * 	| 'acquiredBase' =>  positive/negative change in user's base : BN AMM_RESERVE_PRECISION
+ * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
+ */
+function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType = 'quote', oraclePriceData, useSpread = true) {
+    if (amount.eq(numericConstants_1.ZERO)) {
+        return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
+    }
+    const swapDirection = amm_1.getSwapDirection(inputAssetType, direction);
+    let amm;
+    if (useSpread && market.amm.baseSpread > 0) {
+        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
+        amm = {
+            baseAssetReserve,
+            quoteAssetReserve,
+            sqrtK: sqrtK,
+            pegMultiplier: newPeg,
+        };
+    }
+    else {
+        amm = market.amm;
+    }
+    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(amm, inputAssetType, amount, swapDirection);
+    const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
+    const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
+    const acquiredQuoteAssetamount = amm_1.calculateQuoteAssetAmountSwapped(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
+    return [acquiredBase, acquiredQuote, acquiredQuoteAssetamount];
+}
+exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
+/**
+ * calculateTargetPriceTrade
+ * simple function for finding arbitraging trades
+ * @param market
+ * @param targetPrice
+ * @param pct optional default is 100% gap filling, can set smaller.
+ * @param outputAssetType which asset to trade.
+ * @param useSpread whether or not to consider the spread when calculating the trade size
+ * @returns trade direction/size in order to push price to a targetPrice,
+ *
+ * [
+ *   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
+ * ]
+ */
+function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAssetType = 'quote', oraclePriceData, useSpread = true) {
+    assert_1.assert(market.amm.baseAssetReserve.gt(numericConstants_1.ZERO));
+    assert_1.assert(targetPrice.gt(numericConstants_1.ZERO));
+    assert_1.assert(pct.lte(MAXPCT) && pct.gt(numericConstants_1.ZERO));
+    const markPriceBefore = market_1.calculateMarkPrice(market, oraclePriceData);
+    const bidPriceBefore = market_1.calculateBidPrice(market, oraclePriceData);
+    const askPriceBefore = market_1.calculateAskPrice(market, oraclePriceData);
+    let direction;
+    if (targetPrice.gt(markPriceBefore)) {
+        const priceGap = targetPrice.sub(markPriceBefore);
+        const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
+        targetPrice = markPriceBefore.add(priceGapScaled);
+        direction = types_1.PositionDirection.LONG;
+    }
+    else {
+        const priceGap = markPriceBefore.sub(targetPrice);
+        const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
+        targetPrice = markPriceBefore.sub(priceGapScaled);
+        direction = types_1.PositionDirection.SHORT;
+    }
+    let tradeSize;
+    let baseSize;
+    let baseAssetReserveBefore;
+    let quoteAssetReserveBefore;
+    let peg = market.amm.pegMultiplier;
+    if (useSpread && market.amm.baseSpread > 0) {
+        const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
+        baseAssetReserveBefore = baseAssetReserve;
+        quoteAssetReserveBefore = quoteAssetReserve;
+        peg = newPeg;
+    }
+    else {
+        baseAssetReserveBefore = market.amm.baseAssetReserve;
+        quoteAssetReserveBefore = market.amm.quoteAssetReserve;
+    }
+    const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const k = invariant.mul(numericConstants_1.MARK_PRICE_PRECISION);
+    let baseAssetReserveAfter;
+    let quoteAssetReserveAfter;
+    const biasModifier = new anchor_1.BN(1);
+    let markPriceAfter;
+    if (useSpread &&
+        targetPrice.lt(askPriceBefore) &&
+        targetPrice.gt(bidPriceBefore)) {
+        // no trade, market is at target
+        if (markPriceBefore.gt(targetPrice)) {
+            direction = types_1.PositionDirection.SHORT;
+        }
+        else {
+            direction = types_1.PositionDirection.LONG;
+        }
+        tradeSize = numericConstants_1.ZERO;
+        return [direction, tradeSize, targetPrice, targetPrice];
+    }
+    else if (markPriceBefore.gt(targetPrice)) {
+        // overestimate y2
+        baseAssetReserveAfter = utils_1.squareRootBN(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).sub(biasModifier)).sub(new anchor_1.BN(1));
+        quoteAssetReserveAfter = k
+            .div(numericConstants_1.MARK_PRICE_PRECISION)
+            .div(baseAssetReserveAfter);
+        markPriceAfter = amm_1.calculatePrice(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
+        direction = types_1.PositionDirection.SHORT;
+        tradeSize = quoteAssetReserveBefore
+            .sub(quoteAssetReserveAfter)
+            .mul(peg)
+            .div(numericConstants_1.PEG_PRECISION)
+            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+        baseSize = baseAssetReserveAfter.sub(baseAssetReserveBefore);
+    }
+    else if (markPriceBefore.lt(targetPrice)) {
+        // underestimate y2
+        baseAssetReserveAfter = utils_1.squareRootBN(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).add(biasModifier)).add(new anchor_1.BN(1));
+        quoteAssetReserveAfter = k
+            .div(numericConstants_1.MARK_PRICE_PRECISION)
+            .div(baseAssetReserveAfter);
+        markPriceAfter = amm_1.calculatePrice(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
+        direction = types_1.PositionDirection.LONG;
+        tradeSize = quoteAssetReserveAfter
+            .sub(quoteAssetReserveBefore)
+            .mul(peg)
+            .div(numericConstants_1.PEG_PRECISION)
+            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+        baseSize = baseAssetReserveBefore.sub(baseAssetReserveAfter);
+    }
+    else {
+        // no trade, market is at target
+        direction = types_1.PositionDirection.LONG;
+        tradeSize = numericConstants_1.ZERO;
+        return [direction, tradeSize, targetPrice, targetPrice];
+    }
+    let tp1 = targetPrice;
+    let tp2 = markPriceAfter;
+    let originalDiff = targetPrice.sub(markPriceBefore);
+    if (direction == types_1.PositionDirection.SHORT) {
+        tp1 = markPriceAfter;
+        tp2 = targetPrice;
+        originalDiff = markPriceBefore.sub(targetPrice);
+    }
+    const entryPrice = tradeSize
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(baseSize.abs());
+    assert_1.assert(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');
+    assert_1.assert(tp2.lte(tp1) || tp2.sub(tp1).abs() < 100000, 'Target Price Calculation incorrect' +
+        tp2.toString() +
+        '>=' +
+        tp1.toString() +
+        'err: ' +
+        tp2.sub(tp1).abs().toString());
+    if (outputAssetType == 'quote') {
+        return [direction, tradeSize, entryPrice, targetPrice];
+    }
+    else {
+        return [direction, baseSize, entryPrice, targetPrice];
+    }
+}
+exports.calculateTargetPriceTrade = calculateTargetPriceTrade;

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { MarketAccount, PositionDirection, SwapDirection } from '../types';
+import { MarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -78,28 +78,20 @@ export function calculateTradeSlippage(
 	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());
+		.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
 	);
 
@@ -159,9 +151,9 @@ export function calculateTradeAcquiredAmounts(
 	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];
 }
 
 /**

package/src/math/utils.js

@@ -24,4 +24,3 @@ const squareRootBN = (n, closeness = new __1.BN(1)) => {
     return root;
 };
 exports.squareRootBN = squareRootBN;
-//# sourceMappingURL=utils.js.map

package/src/mockUSDCFaucet.js

@@ -0,0 +1,280 @@
+'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/token_faucet.json')
+);
+class MockUSDCFaucet {
+	constructor(connection, wallet, programId, 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(
+			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.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.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/oracleClientCache.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OracleClientCache = void 0;
+const oracleClient_1 = require("../factory/oracleClient");
+class OracleClientCache {
+    constructor() {
+        this.cache = new Map();
+    }
+    get(oracleSource, connection) {
+        const key = Object.keys(oracleSource)[0];
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        const client = oracleClient_1.getOracleClient(oracleSource, connection);
+        this.cache.set(key, client);
+        return client;
+    }
+}
+exports.OracleClientCache = OracleClientCache;

package/src/oracles/pythClient.js

@@ -0,0 +1,46 @@
+"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.convertPythPrice = exports.PythClient = void 0;
+const client_1 = require("@pythnetwork/client");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+class PythClient {
+    constructor(connection) {
+        this.connection = connection;
+    }
+    getOraclePriceData(pricePublicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accountInfo = yield this.connection.getAccountInfo(pricePublicKey);
+            return this.getOraclePriceDataFromBuffer(accountInfo.data);
+        });
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        const priceData = client_1.parsePriceData(buffer);
+        return {
+            price: convertPythPrice(priceData.aggregate.price, priceData.exponent),
+            slot: new anchor_1.BN(priceData.lastSlot.toString()),
+            confidence: convertPythPrice(priceData.confidence, priceData.exponent),
+            twap: convertPythPrice(priceData.twap.value, priceData.exponent),
+            twapConfidence: convertPythPrice(priceData.twac.value, priceData.exponent),
+            hasSufficientNumberOfDataPoints: true,
+        };
+    }
+}
+exports.PythClient = PythClient;
+function convertPythPrice(price, exponent) {
+    exponent = Math.abs(exponent);
+    const pythPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(exponent).abs());
+    return new anchor_1.BN(price * Math.pow(10, exponent))
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(pythPrecision);
+}
+exports.convertPythPrice = convertPythPrice;