@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.10

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { Market, PositionDirection } from '../types';
+import { MarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -17,10 +17,12 @@ import {
 	calculatePrice,
 	getSwapDirection,
 	AssetType,
-	calculateSpreadReserves,
+	calculateUpdatedAMMSpreadReserves,
+	calculateQuoteAssetAmountSwapped,
 } from './amm';
 import { squareRootBN } from './utils';
 import { isVariant } from '../types';
+import { OraclePriceData } from '../oracles/types';
 
 const MAXPCT = new BN(1000); //percentage units are [0,1000] => [0,1]
 
@@ -57,64 +59,64 @@ export type PriceImpactUnit =
 export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
-	market: Market,
+	market: MarketAccount,
 	inputAssetType: AssetType = 'quote',
+	oraclePriceData?: OraclePriceData,
 	useSpread = true
 ): [BN, BN, BN, BN] {
 	let oldPrice: BN;
 
 	if (useSpread && market.amm.baseSpread > 0) {
 		if (isVariant(direction, 'long')) {
-			oldPrice = calculateAskPrice(market);
+			oldPrice = calculateAskPrice(market, oraclePriceData);
 		} else {
-			oldPrice = calculateBidPrice(market);
+			oldPrice = calculateBidPrice(market, oraclePriceData);
 		}
 	} else {
-		oldPrice = calculateMarkPrice(market);
+		oldPrice = calculateMarkPrice(market, oraclePriceData);
 	}
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO, oldPrice, oldPrice];
 	}
-	const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(
-		direction,
-		amount,
-		market,
-		inputAssetType,
-		useSpread
-	);
+	const [acquiredBaseReserve, acquiredQuoteReserve, acquiredQuoteAssetAmount] =
+		calculateTradeAcquiredAmounts(
+			direction,
+			amount,
+			market,
+			inputAssetType,
+			oraclePriceData,
+			useSpread
+		);
 
-	const entryPrice = calculatePrice(
-		acquiredBase,
-		acquiredQuote,
-		market.amm.pegMultiplier
-	).mul(new BN(-1));
+	const entryPrice = acquiredQuoteAssetAmount
+		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.mul(MARK_PRICE_PRECISION)
+		.div(acquiredBaseReserve.abs());
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 	if (useSpread && market.amm.baseSpread > 0) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			direction
-		);
+		const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+			calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
 		amm = {
 			baseAssetReserve,
 			quoteAssetReserve,
-			sqrtK: market.amm.sqrtK,
-			pegMultiplier: market.amm.pegMultiplier,
+			sqrtK: sqrtK,
+			pegMultiplier: newPeg,
 		};
 	} else {
 		amm = market.amm;
 	}
 
 	const newPrice = calculatePrice(
-		amm.baseAssetReserve.sub(acquiredBase),
-		amm.quoteAssetReserve.sub(acquiredQuote),
+		amm.baseAssetReserve.sub(acquiredBaseReserve),
+		amm.quoteAssetReserve.sub(acquiredQuoteReserve),
 		amm.pegMultiplier
 	);
 
 	if (direction == PositionDirection.SHORT) {
-		assert(newPrice.lt(oldPrice));
+		assert(newPrice.lte(oldPrice));
 	} else {
-		assert(oldPrice.lt(newPrice));
+		assert(oldPrice.lte(newPrice));
 	}
 
 	const pctMaxSlippage = newPrice
@@ -145,27 +147,26 @@ export function calculateTradeSlippage(
 export function calculateTradeAcquiredAmounts(
 	direction: PositionDirection,
 	amount: BN,
-	market: Market,
+	market: MarketAccount,
 	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);
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 	if (useSpread && market.amm.baseSpread > 0) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			direction
-		);
+		const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+			calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
 		amm = {
 			baseAssetReserve,
 			quoteAssetReserve,
-			sqrtK: market.amm.sqrtK,
-			pegMultiplier: market.amm.pegMultiplier,
+			sqrtK: sqrtK,
+			pegMultiplier: newPeg,
 		};
 	} else {
 		amm = market.amm;
@@ -176,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];
 }
 
 /**
@@ -197,19 +204,20 @@ export function calculateTradeAcquiredAmounts(
  * ]
  */
 export function calculateTargetPriceTrade(
-	market: Market,
+	market: MarketAccount,
 	targetPrice: BN,
 	pct: BN = MAXPCT,
 	outputAssetType: AssetType = 'quote',
+	oraclePriceData?: OraclePriceData,
 	useSpread = true
 ): [PositionDirection, BN, BN, BN] {
 	assert(market.amm.baseAssetReserve.gt(ZERO));
 	assert(targetPrice.gt(ZERO));
 	assert(pct.lte(MAXPCT) && pct.gt(ZERO));
 
-	const markPriceBefore = calculateMarkPrice(market);
-	const bidPriceBefore = calculateBidPrice(market);
-	const askPriceBefore = calculateAskPrice(market);
+	const markPriceBefore = calculateMarkPrice(market, oraclePriceData);
+	const bidPriceBefore = calculateBidPrice(market, oraclePriceData);
+	const askPriceBefore = calculateAskPrice(market, oraclePriceData);
 
 	let direction;
 	if (targetPrice.gt(markPriceBefore)) {
@@ -230,19 +238,19 @@ export function calculateTargetPriceTrade(
 	let baseAssetReserveBefore: BN;
 	let quoteAssetReserveBefore: BN;
 
+	let peg = market.amm.pegMultiplier;
+
 	if (useSpread && market.amm.baseSpread > 0) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			direction
-		);
+		const { baseAssetReserve, quoteAssetReserve, newPeg } =
+			calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
 		baseAssetReserveBefore = baseAssetReserve;
 		quoteAssetReserveBefore = quoteAssetReserve;
+		peg = newPeg;
 	} else {
 		baseAssetReserveBefore = market.amm.baseAssetReserve;
 		quoteAssetReserveBefore = market.amm.quoteAssetReserve;
 	}
 
-	const peg = market.amm.pegMultiplier;
 	const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
 	const k = invariant.mul(MARK_PRICE_PRECISION);
 

package/src/math/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareRootBN = void 0;
+const __1 = require("../");
+const squareRootBN = (n, closeness = new __1.BN(1)) => {
+    // Assuming the sqrt of n as n only
+    let x = n;
+    // The closed guess will be stored in the root
+    let root;
+    // To count the number of iterations
+    let count = 0;
+    const TWO = new __1.BN(2);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    while (count < Number.MAX_SAFE_INTEGER) {
+        count++;
+        // Calculate more closed x
+        root = x.add(n.div(x)).div(TWO);
+        // Check for closeness
+        if (x.sub(root).abs().lte(closeness))
+            break;
+        // Update root
+        x = root;
+    }
+    return root;
+};
+exports.squareRootBN = squareRootBN;

package/src/math/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":";;;AAAA,2BAAyB;AAElB,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,EAAE,EAAE;IACxD,mCAAmC;IACnC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEV,8CAA8C;IAC9C,IAAI,IAAI,CAAC;IAET,oCAAoC;IACpC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,MAAM,GAAG,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,CAAC;IAEtB,6DAA6D;IAC7D,OAAO,KAAK,GAAG,MAAM,CAAC,gBAAgB,EAAE;QACvC,KAAK,EAAE,CAAC;QAER,0BAA0B;QAC1B,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEhC,sBAAsB;QACtB,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,MAAM;QAE5C,cAAc;QACd,CAAC,GAAG,IAAI,CAAC;KACT;IAED,OAAO,IAAI,CAAC;AACb,CAAC,CAAC;AA1BW,QAAA,YAAY,gBA0BvB"}

package/src/mockUSDCFaucet.js

@@ -0,0 +1,171 @@
+"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/mock_usdc_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/oracleClientCache.ts

@@ -0,0 +1,20 @@
+import { OracleClient } from './types';
+import { OracleSource } from '../types';
+import { getOracleClient } from '../factory/oracleClient';
+import { Connection } from '@solana/web3.js';
+
+export class OracleClientCache {
+	cache = new Map<string, OracleClient>();
+	public constructor() {}
+
+	public get(oracleSource: OracleSource, connection: Connection) {
+		const key = Object.keys(oracleSource)[0];
+		if (this.cache.has(key)) {
+			return this.cache.get(key);
+		}
+
+		const client = getOracleClient(oracleSource, connection);
+		this.cache.set(key, client);
+		return client;
+	}
+}

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;

package/src/oracles/pythClient.ts

@@ -1,21 +1,16 @@
-import { parsePriceData, PriceData } from '@pythnetwork/client';
+import { parsePriceData } from '@pythnetwork/client';
 import { Connection, PublicKey } from '@solana/web3.js';
-import { OraclePriceData } from './types';
+import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
 import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
 
-export class PythClient {
+export class PythClient implements OracleClient {
 	private connection: Connection;
 
 	public constructor(connection: Connection) {
 		this.connection = connection;
 	}
 
-	public async getPriceData(pricePublicKey: PublicKey): Promise<PriceData> {
-		const account = await this.connection.getAccountInfo(pricePublicKey);
-		return parsePriceData(account.data);
-	}
-
 	public async getOraclePriceData(
 		pricePublicKey: PublicKey
 	): Promise<OraclePriceData> {
@@ -23,9 +18,7 @@ export class PythClient {
 		return this.getOraclePriceDataFromBuffer(accountInfo.data);
 	}
 
-	public async getOraclePriceDataFromBuffer(
-		buffer: Buffer
-	): Promise<OraclePriceData> {
+	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
 		const priceData = parsePriceData(buffer);
 		return {
 			price: convertPythPrice(priceData.aggregate.price, priceData.exponent),

package/src/oracles/quoteAssetOracleClient.js

@@ -0,0 +1,32 @@
+"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.QuoteAssetOracleClient = exports.QUOTE_ORACLE_PRICE_DATA = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+exports.QUOTE_ORACLE_PRICE_DATA = {
+    price: numericConstants_1.MARK_PRICE_PRECISION,
+    slot: new anchor_1.BN(0),
+    confidence: new anchor_1.BN(1),
+    hasSufficientNumberOfDataPoints: true,
+};
+class QuoteAssetOracleClient {
+    constructor() { }
+    getOraclePriceData(_pricePublicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(exports.QUOTE_ORACLE_PRICE_DATA);
+        });
+    }
+    getOraclePriceDataFromBuffer(_buffer) {
+        return exports.QUOTE_ORACLE_PRICE_DATA;
+    }
+}
+exports.QuoteAssetOracleClient = QuoteAssetOracleClient;

package/src/oracles/quoteAssetOracleClient.ts

@@ -0,0 +1,25 @@
+import { PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BN } from '@project-serum/anchor';
+import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
+
+export const QUOTE_ORACLE_PRICE_DATA: OraclePriceData = {
+	price: MARK_PRICE_PRECISION,
+	slot: new BN(0),
+	confidence: new BN(1),
+	hasSufficientNumberOfDataPoints: true,
+};
+
+export class QuoteAssetOracleClient implements OracleClient {
+	public constructor() {}
+
+	public async getOraclePriceData(
+		_pricePublicKey: PublicKey
+	): Promise<OraclePriceData> {
+		return Promise.resolve(QUOTE_ORACLE_PRICE_DATA);
+	}
+
+	public getOraclePriceDataFromBuffer(_buffer: Buffer): OraclePriceData {
+		return QUOTE_ORACLE_PRICE_DATA;
+	}
+}

package/src/oracles/switchboardClient.js

@@ -0,0 +1,69 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwitchboardClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const wallet_1 = require("../wallet");
+const switchboard_v2_json_1 = __importDefault(require("../idl/switchboard_v2.json"));
+let program;
+class SwitchboardClient {
+    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 program = this.getProgram();
+        const aggregatorAccountData = program.account.aggregatorAccountData.coder.accounts.decode('AggregatorAccountData', buffer);
+        const price = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound.result);
+        const confidence = convertSwitchboardDecimal(aggregatorAccountData.latestConfirmedRound
+            .stdDeviation);
+        const hasSufficientNumberOfDataPoints = aggregatorAccountData.latestConfirmedRound.numSuccess >=
+            aggregatorAccountData.minOracleResults;
+        const slot = aggregatorAccountData.latestConfirmedRound.roundOpenSlot;
+        return {
+            price,
+            slot,
+            confidence,
+            hasSufficientNumberOfDataPoints,
+        };
+    }
+    getProgram() {
+        if (program) {
+            return program;
+        }
+        program = getSwitchboardProgram(this.connection);
+        return program;
+    }
+}
+exports.SwitchboardClient = SwitchboardClient;
+function getSwitchboardProgram(connection) {
+    const DEFAULT_KEYPAIR = web3_js_1.Keypair.fromSeed(new Uint8Array(32).fill(1));
+    const programId = web3_js_1.PublicKey.default;
+    const wallet = new wallet_1.Wallet(DEFAULT_KEYPAIR);
+    const provider = new anchor_1.AnchorProvider(connection, wallet, {});
+    return new anchor_1.Program(switchboard_v2_json_1.default, programId, provider);
+}
+function convertSwitchboardDecimal(switchboardDecimal) {
+    const switchboardPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(switchboardDecimal.scale));
+    return switchboardDecimal.mantissa
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(switchboardPrecision);
+}