@drift-labs/sdk 0.2.0-master.10 → 0.2.0-master.13

package/src/util/getTokenAddress.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenAddress = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const getTokenAddress = (mintAddress, userPubKey) => {
+    return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
+};
+exports.getTokenAddress = getTokenAddress;

package/src/util/getTokenAddress.ts

@@ -0,0 +1,18 @@
+import {
+	Token,
+	ASSOCIATED_TOKEN_PROGRAM_ID,
+	TOKEN_PROGRAM_ID,
+} from '@solana/spl-token';
+import { PublicKey } from '@solana/web3.js';
+
+export const getTokenAddress = (
+	mintAddress: string,
+	userPubKey: string
+): Promise<PublicKey> => {
+	return Token.getAssociatedTokenAddress(
+		ASSOCIATED_TOKEN_PROGRAM_ID,
+		TOKEN_PROGRAM_ID,
+		new PublicKey(mintAddress),
+		new PublicKey(userPubKey)
+	);
+};

package/tests/bn/test.ts

@@ -125,6 +125,8 @@ describe('BigNum Tests', () => {
 		expect(BigNum.fromPrint('1234567').toMillified(5)).to.equal('1.2345M');
 		expect(BigNum.fromPrint('12345678').toMillified(5)).to.equal('12.345M');
 		expect(BigNum.fromPrint('123456789').toMillified(5)).to.equal('123.45M');
+
+		expect(BigNum.from(-95, 2).print()).to.equal('-0.95');
 	});
 
 	it('can initialise from string values correctly', () => {

package/src/addresses/pda.js

@@ -1,104 +0,0 @@
-"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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBankVaultAuthorityPublicKey = exports.getBankVaultPublicKey = exports.getBankPublicKey = exports.getMarketPublicKey = exports.getUserAccountPublicKeySync = exports.getUserAccountPublicKey = exports.getUserAccountPublicKeyAndNonce = exports.getClearingHouseStateAccountPublicKey = exports.getClearingHouseStateAccountPublicKeyAndNonce = void 0;
-const anchor = __importStar(require("@project-serum/anchor"));
-function getClearingHouseStateAccountPublicKeyAndNonce(programId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return anchor.web3.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('clearing_house'))], programId);
-    });
-}
-exports.getClearingHouseStateAccountPublicKeyAndNonce = getClearingHouseStateAccountPublicKeyAndNonce;
-function getClearingHouseStateAccountPublicKey(programId) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return (yield getClearingHouseStateAccountPublicKeyAndNonce(programId))[0];
-    });
-}
-exports.getClearingHouseStateAccountPublicKey = getClearingHouseStateAccountPublicKey;
-function getUserAccountPublicKeyAndNonce(programId, authority, userId = 0) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return anchor.web3.PublicKey.findProgramAddress([
-            Buffer.from(anchor.utils.bytes.utf8.encode('user')),
-            authority.toBuffer(),
-            Uint8Array.from([userId]),
-        ], programId);
-    });
-}
-exports.getUserAccountPublicKeyAndNonce = getUserAccountPublicKeyAndNonce;
-function getUserAccountPublicKey(programId, authority, userId = 0) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return (yield getUserAccountPublicKeyAndNonce(programId, authority, userId))[0];
-    });
-}
-exports.getUserAccountPublicKey = getUserAccountPublicKey;
-function getUserAccountPublicKeySync(programId, authority, userId = 0) {
-    return anchor.web3.PublicKey.findProgramAddressSync([
-        Buffer.from(anchor.utils.bytes.utf8.encode('user')),
-        authority.toBuffer(),
-        Uint8Array.from([userId]),
-    ], programId)[0];
-}
-exports.getUserAccountPublicKeySync = getUserAccountPublicKeySync;
-function getMarketPublicKey(programId, marketIndex) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return (yield anchor.web3.PublicKey.findProgramAddress([
-            Buffer.from(anchor.utils.bytes.utf8.encode('market')),
-            marketIndex.toArrayLike(Buffer, 'le', 8),
-        ], programId))[0];
-    });
-}
-exports.getMarketPublicKey = getMarketPublicKey;
-function getBankPublicKey(programId, bankIndex) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return (yield anchor.web3.PublicKey.findProgramAddress([
-            Buffer.from(anchor.utils.bytes.utf8.encode('bank')),
-            bankIndex.toArrayLike(Buffer, 'le', 8),
-        ], programId))[0];
-    });
-}
-exports.getBankPublicKey = getBankPublicKey;
-function getBankVaultPublicKey(programId, bankIndex) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return (yield anchor.web3.PublicKey.findProgramAddress([
-            Buffer.from(anchor.utils.bytes.utf8.encode('bank_vault')),
-            bankIndex.toArrayLike(Buffer, 'le', 8),
-        ], programId))[0];
-    });
-}
-exports.getBankVaultPublicKey = getBankVaultPublicKey;
-function getBankVaultAuthorityPublicKey(programId, bankIndex) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return (yield anchor.web3.PublicKey.findProgramAddress([
-            Buffer.from(anchor.utils.bytes.utf8.encode('bank_vault_authority')),
-            bankIndex.toArrayLike(Buffer, 'le', 8),
-        ], programId))[0];
-    });
-}
-exports.getBankVaultAuthorityPublicKey = getBankVaultAuthorityPublicKey;

package/src/math/bankBalance.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateInterestAccumulated = exports.getTokenAmount = exports.getBalance = void 0;
-const types_1 = require("../types");
-const anchor_1 = require("@project-serum/anchor");
-const numericConstants_1 = require("../constants/numericConstants");
-function getBalance(tokenAmount, bank, balanceType) {
-    const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - bank.decimals));
-    const cumulativeInterest = types_1.isVariant(balanceType, 'deposit')
-        ? bank.cumulativeDepositInterest
-        : bank.cumulativeBorrowInterest;
-    let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
-    if (!balance.eq(numericConstants_1.ZERO) && types_1.isVariant(balanceType, 'borrow')) {
-        balance = balance.add(numericConstants_1.ONE);
-    }
-    return balance;
-}
-exports.getBalance = getBalance;
-function getTokenAmount(balanceAmount, bank, balanceType) {
-    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - bank.decimals));
-    const cumulativeInterest = types_1.isVariant(balanceType, 'deposit')
-        ? bank.cumulativeDepositInterest
-        : bank.cumulativeBorrowInterest;
-    return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
-}
-exports.getTokenAmount = getTokenAmount;
-function calculateInterestAccumulated(bank, now) {
-    const token_deposit_amount = getTokenAmount(bank.depositBalance, bank, types_1.BankBalanceType.DEPOSIT);
-    const token_borrow_amount = getTokenAmount(bank.borrowBalance, bank, types_1.BankBalanceType.BORROW);
-    let utilization;
-    if (token_borrow_amount.eq(numericConstants_1.ZERO) && token_deposit_amount.eq(numericConstants_1.ZERO)) {
-        utilization = numericConstants_1.ZERO;
-    }
-    else if (token_deposit_amount.eq(numericConstants_1.ZERO)) {
-        utilization = numericConstants_1.BANK_UTILIZATION_PRECISION;
-    }
-    else {
-        utilization = token_borrow_amount
-            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
-            .div(token_deposit_amount);
-    }
-    let interest_rate;
-    if (utilization.gt(bank.optimalUtilization)) {
-        const surplusUtilization = utilization.sub(bank.optimalUtilization);
-        const borrowRateSlope = bank.maxBorrowRate
-            .sub(bank.optimalBorrowRate)
-            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
-            .div(numericConstants_1.BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
-        interest_rate = bank.optimalBorrowRate.add(surplusUtilization.mul(borrowRateSlope).div(numericConstants_1.BANK_UTILIZATION_PRECISION));
-    }
-    else {
-        const borrowRateSlope = bank.optimalBorrowRate
-            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
-            .div(numericConstants_1.BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
-        interest_rate = utilization
-            .mul(borrowRateSlope)
-            .div(numericConstants_1.BANK_UTILIZATION_PRECISION);
-    }
-    const timeSinceLastUpdate = now.sub(bank.lastUpdated);
-    const modifiedBorrowRate = interest_rate.mul(timeSinceLastUpdate);
-    const modifiedDepositRate = modifiedBorrowRate
-        .mul(utilization)
-        .div(numericConstants_1.BANK_UTILIZATION_PRECISION);
-    const borrowInterest = bank.cumulativeBorrowInterest
-        .mul(modifiedBorrowRate)
-        .div(numericConstants_1.ONE_YEAR)
-        .div(numericConstants_1.BANK_INTEREST_PRECISION)
-        .add(numericConstants_1.ONE);
-    const depositInterest = bank.cumulativeDepositInterest
-        .mul(modifiedDepositRate)
-        .div(numericConstants_1.ONE_YEAR)
-        .div(numericConstants_1.BANK_INTEREST_PRECISION);
-    return { borrowInterest, depositInterest };
-}
-exports.calculateInterestAccumulated = calculateInterestAccumulated;

package/src/math/market.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = void 0;
-const types_1 = require("../types");
-const amm_1 = require("./amm");
-/**
- * Calculates market mark price
- *
- * @param market
- * @return markPrice : Precision MARK_PRICE_PRECISION
- */
-function calculateMarkPrice(market, oraclePriceData) {
-    const newAmm = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
-    return amm_1.calculatePrice(newAmm.baseAssetReserve, newAmm.quoteAssetReserve, newAmm.pegMultiplier);
-}
-exports.calculateMarkPrice = calculateMarkPrice;
-/**
- * Calculates market bid price
- *
- * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
- */
-function calculateBidPrice(market, oraclePriceData) {
-    const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, types_1.PositionDirection.SHORT, oraclePriceData);
-    return amm_1.calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
-}
-exports.calculateBidPrice = calculateBidPrice;
-/**
- * Calculates market ask price
- *
- * @param market
- * @return bidPrice : Precision MARK_PRICE_PRECISION
- */
-function calculateAskPrice(market, oraclePriceData) {
-    const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, types_1.PositionDirection.LONG, oraclePriceData);
-    return amm_1.calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
-}
-exports.calculateAskPrice = calculateAskPrice;
-function calculateNewMarketAfterTrade(baseAssetAmount, direction, market) {
-    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(market.amm, 'base', baseAssetAmount.abs(), amm_1.getSwapDirection('base', direction));
-    const newAmm = Object.assign({}, market.amm);
-    const newMarket = Object.assign({}, market);
-    newMarket.amm = newAmm;
-    newMarket.amm.quoteAssetReserve = newQuoteAssetReserve;
-    newMarket.amm.baseAssetReserve = newBaseAssetReserve;
-    return newMarket;
-}
-exports.calculateNewMarketAfterTrade = calculateNewMarketAfterTrade;
-function calculateMarkOracleSpread(market, oraclePriceData) {
-    const markPrice = calculateMarkPrice(market, oraclePriceData);
-    return calculateOracleSpread(markPrice, oraclePriceData);
-}
-exports.calculateMarkOracleSpread = calculateMarkOracleSpread;
-function calculateOracleSpread(price, oraclePriceData) {
-    return price.sub(oraclePriceData.price);
-}
-exports.calculateOracleSpread = calculateOracleSpread;

package/src/math/orders.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLimitPrice = exports.standardizeBaseAssetAmount = exports.isOrderReduceOnly = exports.isOrderRiskIncreasingInSameDirection = exports.isOrderRiskIncreasing = void 0;
-const types_1 = require("../types");
-const numericConstants_1 = require("../constants/numericConstants");
-const anchor_1 = require("@project-serum/anchor");
-const auction_1 = require("./auction");
-const market_1 = require("./market");
-function isOrderRiskIncreasing(user, order) {
-    if (types_1.isVariant(order.status, 'init')) {
-        return false;
-    }
-    const position = user.getUserPosition(order.marketIndex) ||
-        user.getEmptyPosition(order.marketIndex);
-    // if no position exists, it's risk increasing
-    if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-        return true;
-    }
-    // if position is long and order is long
-    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && types_1.isVariant(order.direction, 'long')) {
-        return true;
-    }
-    // if position is short and order is short
-    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
-        types_1.isVariant(order.direction, 'short')) {
-        return true;
-    }
-    const baseAssetAmountToFill = order.baseAssetAmount.sub(order.baseAssetAmountFilled);
-    // if order will flip position
-    if (baseAssetAmountToFill.gt(position.baseAssetAmount.abs().mul(numericConstants_1.TWO))) {
-        return true;
-    }
-    return false;
-}
-exports.isOrderRiskIncreasing = isOrderRiskIncreasing;
-function isOrderRiskIncreasingInSameDirection(user, order) {
-    if (types_1.isVariant(order.status, 'init')) {
-        return false;
-    }
-    const position = user.getUserPosition(order.marketIndex) ||
-        user.getEmptyPosition(order.marketIndex);
-    // if no position exists, it's risk increasing
-    if (position.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-        return true;
-    }
-    // if position is long and order is long
-    if (position.baseAssetAmount.gt(numericConstants_1.ZERO) && types_1.isVariant(order.direction, 'long')) {
-        return true;
-    }
-    // if position is short and order is short
-    if (position.baseAssetAmount.lt(numericConstants_1.ZERO) &&
-        types_1.isVariant(order.direction, 'short')) {
-        return true;
-    }
-    return false;
-}
-exports.isOrderRiskIncreasingInSameDirection = isOrderRiskIncreasingInSameDirection;
-function isOrderReduceOnly(user, order) {
-    if (types_1.isVariant(order.status, 'init')) {
-        return false;
-    }
-    const position = user.getUserPosition(order.marketIndex) ||
-        user.getEmptyPosition(order.marketIndex);
-    // if position is long and order is long
-    if (position.baseAssetAmount.gte(numericConstants_1.ZERO) &&
-        types_1.isVariant(order.direction, 'long')) {
-        return false;
-    }
-    // if position is short and order is short
-    if (position.baseAssetAmount.lte(numericConstants_1.ZERO) &&
-        types_1.isVariant(order.direction, 'short')) {
-        return false;
-    }
-    return true;
-}
-exports.isOrderReduceOnly = isOrderReduceOnly;
-function standardizeBaseAssetAmount(baseAssetAmount, stepSize) {
-    const remainder = baseAssetAmount.mod(stepSize);
-    return baseAssetAmount.sub(remainder);
-}
-exports.standardizeBaseAssetAmount = standardizeBaseAssetAmount;
-function getLimitPrice(order, market, oraclePriceData, slot) {
-    let limitPrice;
-    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
-        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-    }
-    else if (types_1.isOneOfVariant(order.orderType, ['market', 'triggerMarket'])) {
-        if (auction_1.isAuctionComplete(order, slot)) {
-            limitPrice = auction_1.getAuctionPrice(order, slot);
-        }
-        else if (!order.price.eq(numericConstants_1.ZERO)) {
-            limitPrice = order.price;
-        }
-        else if (types_1.isVariant(order.direction, 'long')) {
-            const askPrice = market_1.calculateAskPrice(market, oraclePriceData);
-            const delta = askPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
-            limitPrice = askPrice.add(delta);
-        }
-        else {
-            const bidPrice = market_1.calculateBidPrice(market, oraclePriceData);
-            const delta = bidPrice.div(new anchor_1.BN(market.amm.maxSlippageRatio));
-            limitPrice = bidPrice.sub(delta);
-        }
-    }
-    else {
-        limitPrice = order.price;
-    }
-    return limitPrice;
-}
-exports.getLimitPrice = getLimitPrice;

package/src/math/position.js

@@ -1,140 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
-const __1 = require("../");
-const numericConstants_1 = require("../constants/numericConstants");
-const types_1 = require("../types");
-const amm_1 = require("./amm");
-/**
- * calculateBaseAssetValue
- * = market value of closing entire position
- * @param market
- * @param userPosition
- * @param oraclePriceData
- * @returns Base Asset Value. : Precision QUOTE_PRECISION
- */
-function calculateBaseAssetValue(market, userPosition, oraclePriceData) {
-    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-        return numericConstants_1.ZERO;
-    }
-    const directionToClose = findDirectionToClose(userPosition);
-    let prepegAmm;
-    if (market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, directionToClose, oraclePriceData);
-        prepegAmm = {
-            baseAssetReserve,
-            quoteAssetReserve,
-            sqrtK: sqrtK,
-            pegMultiplier: newPeg,
-        };
-    }
-    else {
-        prepegAmm = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
-    }
-    const [newQuoteAssetReserve, _] = amm_1.calculateAmmReservesAfterSwap(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), amm_1.getSwapDirection('base', directionToClose));
-    switch (directionToClose) {
-        case types_1.PositionDirection.SHORT:
-            return prepegAmm.quoteAssetReserve
-                .sub(newQuoteAssetReserve)
-                .mul(prepegAmm.pegMultiplier)
-                .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-        case types_1.PositionDirection.LONG:
-            return newQuoteAssetReserve
-                .sub(prepegAmm.quoteAssetReserve)
-                .mul(prepegAmm.pegMultiplier)
-                .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
-                .add(numericConstants_1.ONE);
-    }
-}
-exports.calculateBaseAssetValue = calculateBaseAssetValue;
-/**
- * calculatePositionPNL
- * = BaseAssetAmount * (Avg Exit Price - Avg Entry Price)
- * @param market
- * @param marketPosition
- * @param withFunding (adds unrealized funding payment pnl to result)
- * @returns BaseAssetAmount : Precision QUOTE_PRECISION
- */
-function calculatePositionPNL(market, marketPosition, withFunding = false, oraclePriceData) {
-    if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-        return numericConstants_1.ZERO;
-    }
-    const baseAssetValue = calculateBaseAssetValue(market, marketPosition, oraclePriceData);
-    let pnl;
-    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
-        pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
-    }
-    else {
-        pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue);
-    }
-    if (withFunding) {
-        const fundingRatePnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
-        pnl = pnl.add(fundingRatePnL);
-    }
-    return pnl;
-}
-exports.calculatePositionPNL = calculatePositionPNL;
-/**
- *
- * @param market
- * @param marketPosition
- * @returns // TODO-PRECISION
- */
-function calculatePositionFundingPNL(market, marketPosition) {
-    if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-        return numericConstants_1.ZERO;
-    }
-    let ammCumulativeFundingRate;
-    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
-        ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
-    }
-    else {
-        ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
-    }
-    const perPositionFundingRate = ammCumulativeFundingRate
-        .sub(marketPosition.lastCumulativeFundingRate)
-        .mul(marketPosition.baseAssetAmount)
-        .div(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.FUNDING_PAYMENT_PRECISION)
-        .mul(new __1.BN(-1));
-    return perPositionFundingRate;
-}
-exports.calculatePositionFundingPNL = calculatePositionFundingPNL;
-function positionIsAvailable(position) {
-    return (position.baseAssetAmount.eq(numericConstants_1.ZERO) &&
-        position.openOrders.eq(numericConstants_1.ZERO) &&
-        position.unsettledPnl.eq(numericConstants_1.ZERO));
-}
-exports.positionIsAvailable = positionIsAvailable;
-/**
- *
- * @param userPosition
- * @returns Precision: MARK_PRICE_PRECISION (10^10)
- */
-function calculateEntryPrice(userPosition) {
-    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-        return numericConstants_1.ZERO;
-    }
-    return userPosition.quoteAssetAmount
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
-        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
-        .div(userPosition.baseAssetAmount)
-        .abs();
-}
-exports.calculateEntryPrice = calculateEntryPrice;
-function findDirectionToClose(userPosition) {
-    return userPosition.baseAssetAmount.gt(numericConstants_1.ZERO)
-        ? types_1.PositionDirection.SHORT
-        : types_1.PositionDirection.LONG;
-}
-exports.findDirectionToClose = findDirectionToClose;
-function positionCurrentDirection(userPosition) {
-    return userPosition.baseAssetAmount.gte(numericConstants_1.ZERO)
-        ? types_1.PositionDirection.LONG
-        : types_1.PositionDirection.SHORT;
-}
-exports.positionCurrentDirection = positionCurrentDirection;
-function isEmptyPosition(userPosition) {
-    return (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) && userPosition.openOrders.eq(numericConstants_1.ZERO));
-}
-exports.isEmptyPosition = isEmptyPosition;

package/src/orders.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
-const types_1 = require("./types");
-const _1 = require(".");
-const market_1 = require("./math/market");
-const numericConstants_1 = require("./constants/numericConstants");
-const amm_1 = require("./math/amm");
-const position_1 = require("./math/position");
-function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
-    if (types_1.isVariant(order.status, 'init')) {
-        return null;
-    }
-    const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(market, order);
-    if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
-        return null;
-    }
-    const userAccountAfter = Object.assign({}, userAccount);
-    const userPositionAfter = Object.assign({}, userPosition);
-    const currentPositionDirection = position_1.positionCurrentDirection(userPosition);
-    const increasePosition = userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) ||
-        isSameDirection(order.direction, currentPositionDirection);
-    if (increasePosition) {
-        const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
-        const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(market, marketAfter);
-        userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
-        userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(quoteAssetAmountSwapped);
-        return [userAccountAfter, userPositionAfter, marketAfter];
-    }
-    else {
-        const reversePosition = baseAssetAmountToTrade.gt(userPosition.baseAssetAmount.abs());
-        if (reversePosition) {
-            const intermediateMarket = market_1.calculateNewMarketAfterTrade(userPosition.baseAssetAmount, position_1.findDirectionToClose(userPosition), market);
-            const { quoteAssetAmountSwapped: baseAssetValue } = calculateAmountSwapped(market, intermediateMarket);
-            let pnl;
-            if (types_1.isVariant(currentPositionDirection, 'long')) {
-                pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
-            }
-            else {
-                pnl = userPosition.quoteAssetAmount.sub(baseAssetValue);
-            }
-            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-            const baseAssetAmountLeft = baseAssetAmountToTrade.sub(userPosition.baseAssetAmount.abs());
-            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountLeft, order.direction, intermediateMarket);
-            const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(intermediateMarket, marketAfter);
-            userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
-            userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
-            return [userAccountAfter, userPositionAfter, marketAfter];
-        }
-        else {
-            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
-            const { quoteAssetAmountSwapped: baseAssetValue, baseAssetAmountSwapped, } = calculateAmountSwapped(market, marketAfter);
-            const costBasisRealized = userPosition.quoteAssetAmount
-                .mul(baseAssetAmountSwapped.abs())
-                .div(userPosition.baseAssetAmount.abs());
-            let pnl;
-            if (types_1.isVariant(currentPositionDirection, 'long')) {
-                pnl = baseAssetValue.sub(costBasisRealized);
-            }
-            else {
-                pnl = costBasisRealized.sub(baseAssetValue);
-            }
-            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-            userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
-            userPositionAfter.quoteAssetAmount =
-                userPositionAfter.quoteAssetAmount.sub(costBasisRealized);
-            return [userAccountAfter, userPositionAfter, marketAfter];
-        }
-    }
-}
-exports.calculateNewStateAfterOrder = calculateNewStateAfterOrder;
-function calculateAmountSwapped(marketBefore, marketAfter) {
-    return {
-        quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
-            .sub(marketAfter.amm.quoteAssetReserve)
-            .abs()
-            .mul(marketBefore.amm.pegMultiplier)
-            .div(numericConstants_1.PEG_PRECISION)
-            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO),
-        baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(marketAfter.amm.baseAssetReserve),
-    };
-}
-function calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData) {
-    if (types_1.isVariant(order.orderType, 'limit')) {
-        return calculateAmountToTradeForLimit(market, order, oraclePriceData);
-    }
-    else if (types_1.isVariant(order.orderType, 'triggerLimit')) {
-        return calculateAmountToTradeForTriggerLimit(market, order);
-    }
-    else if (types_1.isVariant(order.orderType, 'market')) {
-        return numericConstants_1.ZERO;
-    }
-    else {
-        return calculateAmountToTradeForTriggerMarket(market, order);
-    }
-}
-exports.calculateBaseAssetAmountMarketCanExecute = calculateBaseAssetAmountMarketCanExecute;
-function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
-    let limitPrice = order.price;
-    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
-        if (!oraclePriceData) {
-            throw Error('Cant calculate limit price for oracle offset oracle without OraclePriceData');
-        }
-        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-    }
-    const [maxAmountToTrade, direction] = amm_1.calculateMaxBaseAssetAmountToTrade(market.amm, limitPrice, order.direction);
-    const baseAssetAmount = _1.standardizeBaseAssetAmount(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
-    // Check that directions are the same
-    const sameDirection = isSameDirection(direction, order.direction);
-    if (!sameDirection) {
-        return numericConstants_1.ZERO;
-    }
-    return baseAssetAmount.gt(order.baseAssetAmount)
-        ? order.baseAssetAmount
-        : baseAssetAmount;
-}
-exports.calculateAmountToTradeForLimit = calculateAmountToTradeForLimit;
-function calculateAmountToTradeForTriggerLimit(market, order) {
-    if (!order.triggered) {
-        return numericConstants_1.ZERO;
-    }
-    return calculateAmountToTradeForLimit(market, order);
-}
-exports.calculateAmountToTradeForTriggerLimit = calculateAmountToTradeForTriggerLimit;
-function isSameDirection(firstDirection, secondDirection) {
-    return ((types_1.isVariant(firstDirection, 'long') && types_1.isVariant(secondDirection, 'long')) ||
-        (types_1.isVariant(firstDirection, 'short') && types_1.isVariant(secondDirection, 'short')));
-}
-function calculateAmountToTradeForTriggerMarket(market, order) {
-    if (!order.triggered) {
-        return numericConstants_1.ZERO;
-    }
-    return order.baseAssetAmount;
-}