@drift-labs/sdk 0.2.0-master.24 → 0.2.0-master.26

package/src/math/trade.js

@@ -1,15 +1,15 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+exports.__esModule = 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]
+var types_1 = require("../types");
+var anchor_1 = require("@project-serum/anchor");
+var assert_1 = require("../assert/assert");
+var numericConstants_1 = require("../constants/numericConstants");
+var market_1 = require("./market");
+var amm_1 = require("./amm");
+var utils_1 = require("./utils");
+var types_2 = require("../types");
+var MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
  * @param direction
@@ -27,53 +27,55 @@ const MAXPCT = new anchor_1.BN(1000); //percentage units are [0,1000] => [0,1]
  *
  * '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;
+function calculateTradeSlippage(direction, amount, market, inputAssetType, oraclePriceData, useSpread) {
+    if (inputAssetType === void 0) { inputAssetType = 'quote'; }
+    if (useSpread === void 0) { useSpread = true; }
+    var oldPrice;
     if (useSpread && market.amm.baseSpread > 0) {
-        if (types_2.isVariant(direction, 'long')) {
-            oldPrice = market_1.calculateAskPrice(market, oraclePriceData);
+        if ((0, types_2.isVariant)(direction, 'long')) {
+            oldPrice = (0, market_1.calculateAskPrice)(market, oraclePriceData);
         }
         else {
-            oldPrice = market_1.calculateBidPrice(market, oraclePriceData);
+            oldPrice = (0, market_1.calculateBidPrice)(market, oraclePriceData);
         }
     }
     else {
-        oldPrice = market_1.calculateMarkPrice(market, oraclePriceData);
+        oldPrice = (0, 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
+    var _a = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread), acquiredBaseReserve = _a[0], acquiredQuoteReserve = _a[1], acquiredQuoteAssetAmount = _a[2];
+    var entryPrice = acquiredQuoteAssetAmount
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .div(acquiredBaseReserve.abs());
-    let amm;
+    var amm;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
+        var _b = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData), baseAssetReserve = _b.baseAssetReserve, quoteAssetReserve = _b.quoteAssetReserve, sqrtK = _b.sqrtK, newPeg = _b.newPeg;
         amm = {
-            baseAssetReserve,
-            quoteAssetReserve,
+            baseAssetReserve: baseAssetReserve,
+            quoteAssetReserve: quoteAssetReserve,
             sqrtK: sqrtK,
-            pegMultiplier: newPeg,
+            pegMultiplier: newPeg
         };
     }
     else {
         amm = market.amm;
     }
-    const newPrice = amm_1.calculatePrice(amm.baseAssetReserve.sub(acquiredBaseReserve), amm.quoteAssetReserve.sub(acquiredQuoteReserve), amm.pegMultiplier);
+    var newPrice = (0, 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));
+        (0, assert_1.assert)(newPrice.lte(oldPrice));
     }
     else {
-        assert_1.assert(oldPrice.lte(newPrice));
+        (0, assert_1.assert)(oldPrice.lte(newPrice));
     }
-    const pctMaxSlippage = newPrice
+    var pctMaxSlippage = newPrice
         .sub(oldPrice)
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .div(oldPrice)
         .abs();
-    const pctAvgSlippage = entryPrice
+    var pctAvgSlippage = entryPrice
         .sub(oldPrice)
         .mul(numericConstants_1.MARK_PRICE_PRECISION)
         .div(oldPrice)
@@ -92,29 +94,31 @@ exports.calculateTradeSlippage = calculateTradeSlippage;
  * 	| '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) {
+function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, oraclePriceData, useSpread) {
+    if (inputAssetType === void 0) { inputAssetType = 'quote'; }
+    if (useSpread === void 0) { 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;
+    var swapDirection = (0, amm_1.getSwapDirection)(inputAssetType, direction);
+    var amm;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
+        var _a = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData), baseAssetReserve = _a.baseAssetReserve, quoteAssetReserve = _a.quoteAssetReserve, sqrtK = _a.sqrtK, newPeg = _a.newPeg;
         amm = {
-            baseAssetReserve,
-            quoteAssetReserve,
+            baseAssetReserve: baseAssetReserve,
+            quoteAssetReserve: quoteAssetReserve,
             sqrtK: sqrtK,
-            pegMultiplier: newPeg,
+            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];
+    var _b = (0, amm_1.calculateAmmReservesAfterSwap)(amm, inputAssetType, amount, swapDirection), newQuoteAssetReserve = _b[0], newBaseAssetReserve = _b[1];
+    var acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
+    var acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
+    var acquiredQuoteAssetAmount = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
+    return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
 }
 exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
 /**
@@ -134,33 +138,36 @@ exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
  *   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;
+function calculateTargetPriceTrade(market, targetPrice, pct, outputAssetType, oraclePriceData, useSpread) {
+    if (pct === void 0) { pct = MAXPCT; }
+    if (outputAssetType === void 0) { outputAssetType = 'quote'; }
+    if (useSpread === void 0) { useSpread = true; }
+    (0, assert_1.assert)(market.amm.baseAssetReserve.gt(numericConstants_1.ZERO));
+    (0, assert_1.assert)(targetPrice.gt(numericConstants_1.ZERO));
+    (0, assert_1.assert)(pct.lte(MAXPCT) && pct.gt(numericConstants_1.ZERO));
+    var markPriceBefore = (0, market_1.calculateMarkPrice)(market, oraclePriceData);
+    var bidPriceBefore = (0, market_1.calculateBidPrice)(market, oraclePriceData);
+    var askPriceBefore = (0, market_1.calculateAskPrice)(market, oraclePriceData);
+    var direction;
     if (targetPrice.gt(markPriceBefore)) {
-        const priceGap = targetPrice.sub(markPriceBefore);
-        const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
+        var priceGap = targetPrice.sub(markPriceBefore);
+        var 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);
+        var priceGap = markPriceBefore.sub(targetPrice);
+        var 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;
+    var tradeSize;
+    var baseSize;
+    var baseAssetReserveBefore;
+    var quoteAssetReserveBefore;
+    var peg = market.amm.pegMultiplier;
     if (useSpread && market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
+        var _a = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, direction, oraclePriceData), baseAssetReserve = _a.baseAssetReserve, quoteAssetReserve = _a.quoteAssetReserve, newPeg = _a.newPeg;
         baseAssetReserveBefore = baseAssetReserve;
         quoteAssetReserveBefore = quoteAssetReserve;
         peg = newPeg;
@@ -169,12 +176,12 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
         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;
+    var invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
+    var k = invariant.mul(numericConstants_1.MARK_PRICE_PRECISION);
+    var baseAssetReserveAfter;
+    var quoteAssetReserveAfter;
+    var biasModifier = new anchor_1.BN(1);
+    var markPriceAfter;
     if (useSpread &&
         targetPrice.lt(askPriceBefore) &&
         targetPrice.gt(bidPriceBefore)) {
@@ -190,11 +197,11 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
     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));
+        baseAssetReserveAfter = (0, 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);
+        markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.SHORT;
         tradeSize = quoteAssetReserveBefore
             .sub(quoteAssetReserveAfter)
@@ -205,11 +212,11 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     }
     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));
+        baseAssetReserveAfter = (0, 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);
+        markPriceAfter = (0, amm_1.calculatePrice)(baseAssetReserveAfter, quoteAssetReserveAfter, peg);
         direction = types_1.PositionDirection.LONG;
         tradeSize = quoteAssetReserveAfter
             .sub(quoteAssetReserveBefore)
@@ -224,20 +231,20 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
         tradeSize = numericConstants_1.ZERO;
         return [direction, tradeSize, targetPrice, targetPrice];
     }
-    let tp1 = targetPrice;
-    let tp2 = markPriceAfter;
-    let originalDiff = targetPrice.sub(markPriceBefore);
+    var tp1 = targetPrice;
+    var tp2 = markPriceAfter;
+    var originalDiff = targetPrice.sub(markPriceBefore);
     if (direction == types_1.PositionDirection.SHORT) {
         tp1 = markPriceAfter;
         tp2 = targetPrice;
         originalDiff = markPriceBefore.sub(targetPrice);
     }
-    const entryPrice = tradeSize
+    var 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' +
+    (0, assert_1.assert)(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');
+    (0, assert_1.assert)(tp2.lte(tp1) || tp2.sub(tp1).abs() < 100000, 'Target Price Calculation incorrect' +
         tp2.toString() +
         '>=' +
         tp1.toString() +

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { MarketAccount, PositionDirection } from '../types';
+import { PerpMarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -59,7 +59,7 @@ export type PriceImpactUnit =
 export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	inputAssetType: AssetType = 'quote',
 	oraclePriceData?: OraclePriceData,
 	useSpread = true
@@ -147,7 +147,7 @@ export function calculateTradeSlippage(
 export function calculateTradeAcquiredAmounts(
 	direction: PositionDirection,
 	amount: BN,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	inputAssetType: AssetType = 'quote',
 	oraclePriceData: OraclePriceData,
 	useSpread = true
@@ -204,7 +204,7 @@ export function calculateTradeAcquiredAmounts(
  * ]
  */
 export function calculateTargetPriceTrade(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	targetPrice: BN,
 	pct: BN = MAXPCT,
 	outputAssetType: AssetType = 'quote',

package/src/math/utils.js

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

package/src/oracles/oracleClientCache.js

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

package/src/oracles/pythClient.js

@@ -8,37 +8,72 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = 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) {
+var client_1 = require("@pythnetwork/client");
+var anchor_1 = require("@project-serum/anchor");
+var numericConstants_1 = require("../constants/numericConstants");
+var PythClient = /** @class */ (function () {
+    function PythClient(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);
+    PythClient.prototype.getOraclePriceData = function (pricePublicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var accountInfo;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.connection.getAccountInfo(pricePublicKey)];
+                    case 1:
+                        accountInfo = _a.sent();
+                        return [2 /*return*/, this.getOraclePriceDataFromBuffer(accountInfo.data)];
+                }
+            });
         });
-    }
-    getOraclePriceDataFromBuffer(buffer) {
-        const priceData = client_1.parsePriceData(buffer);
+    };
+    PythClient.prototype.getOraclePriceDataFromBuffer = function (buffer) {
+        var priceData = (0, 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,
+            hasSufficientNumberOfDataPoints: true
         };
-    }
-}
+    };
+    return PythClient;
+}());
 exports.PythClient = PythClient;
 function convertPythPrice(price, exponent) {
     exponent = Math.abs(exponent);
-    const pythPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(exponent).abs());
+    var 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);

package/src/oracles/quoteAssetOracleClient.js

@@ -8,25 +8,56 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = true;
 exports.QuoteAssetOracleClient = exports.QUOTE_ORACLE_PRICE_DATA = void 0;
-const anchor_1 = require("@project-serum/anchor");
-const numericConstants_1 = require("../constants/numericConstants");
+var anchor_1 = require("@project-serum/anchor");
+var 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,
+    hasSufficientNumberOfDataPoints: true
 };
-class QuoteAssetOracleClient {
-    constructor() { }
-    getOraclePriceData(_pricePublicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return Promise.resolve(exports.QUOTE_ORACLE_PRICE_DATA);
-        });
+var QuoteAssetOracleClient = /** @class */ (function () {
+    function QuoteAssetOracleClient() {
     }
-    getOraclePriceDataFromBuffer(_buffer) {
+    QuoteAssetOracleClient.prototype.getOraclePriceData = function (_pricePublicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Promise.resolve(exports.QUOTE_ORACLE_PRICE_DATA)];
+            });
+        });
+    };
+    QuoteAssetOracleClient.prototype.getOraclePriceDataFromBuffer = function (_buffer) {
         return exports.QUOTE_ORACLE_PRICE_DATA;
-    }
-}
+    };
+    return QuoteAssetOracleClient;
+}());
 exports.QuoteAssetOracleClient = QuoteAssetOracleClient;