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

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/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/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;

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/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);
+}

package/src/oracles/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/orderParams.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
+const types_1 = require("./types");
+function getLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.LIMIT });
+}
+exports.getLimitOrderParams = getLimitOrderParams;
+function getTriggerMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_MARKET });
+}
+exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
+function getTriggerLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_LIMIT });
+}
+exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
+function getMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.MARKET });
+}
+exports.getMarketOrderParams = getMarketOrderParams;

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/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;