@drift-labs/sdk 0.2.0-master.25 → 0.2.0-master.27

package/lib/math/position.js

@@ -52,36 +52,36 @@ exports.calculateBaseAssetValue = calculateBaseAssetValue;
  * calculatePositionPNL
  * = BaseAssetAmount * (Avg Exit Price - Avg Entry Price)
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
  * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
-function calculatePositionPNL(market, marketPosition, withFunding = false, oraclePriceData) {
-    if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-        return marketPosition.quoteAssetAmount;
+function calculatePositionPNL(market, perpPosition, withFunding = false, oraclePriceData) {
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return perpPosition.quoteAssetAmount;
     }
-    const baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, marketPosition, oraclePriceData);
-    const baseAssetValueSign = marketPosition.baseAssetAmount.isNeg()
+    const baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, perpPosition, oraclePriceData);
+    const baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
         ? new __1.BN(-1)
         : new __1.BN(1);
     let pnl = baseAssetValue
         .mul(baseAssetValueSign)
-        .add(marketPosition.quoteAssetAmount);
+        .add(perpPosition.quoteAssetAmount);
     if (withFunding) {
-        const fundingRatePnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        const fundingRatePnL = calculatePositionFundingPNL(market, perpPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
         pnl = pnl.add(fundingRatePnL);
     }
     return pnl;
 }
 exports.calculatePositionPNL = calculatePositionPNL;
-function calculateUnsettledPnl(market, marketPosition, oraclePriceData) {
-    const unrealizedPnl = calculatePositionPNL(market, marketPosition, true, oraclePriceData);
+function calculateUnsettledPnl(market, perpPosition, oraclePriceData) {
+    const unrealizedPnl = calculatePositionPNL(market, perpPosition, true, oraclePriceData);
     let unsettledPnl = unrealizedPnl;
     if (unrealizedPnl.gt(numericConstants_1.ZERO)) {
-        const fundingPnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
-        const maxPositivePnl = __1.BN.max(marketPosition.quoteAssetAmount
-            .sub(marketPosition.quoteEntryAmount)
+        const fundingPnL = calculatePositionFundingPNL(market, perpPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        const maxPositivePnl = __1.BN.max(perpPosition.quoteAssetAmount
+            .sub(perpPosition.quoteEntryAmount)
             .add(fundingPnL), numericConstants_1.ZERO);
         unsettledPnl = __1.BN.min(maxPositivePnl, unrealizedPnl);
     }
@@ -91,23 +91,23 @@ exports.calculateUnsettledPnl = calculateUnsettledPnl;
 /**
  *
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @returns // TODO-PRECISION
  */
-function calculatePositionFundingPNL(market, marketPosition) {
-    if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+function calculatePositionFundingPNL(market, perpPosition) {
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
     let ammCumulativeFundingRate;
-    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+    if (perpPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
         ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
     }
     else {
         ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
     }
     const perPositionFundingRate = ammCumulativeFundingRate
-        .sub(marketPosition.lastCumulativeFundingRate)
-        .mul(marketPosition.baseAssetAmount)
+        .sub(perpPosition.lastCumulativeFundingRate)
+        .mul(perpPosition.baseAssetAmount)
         .div(numericConstants_1.AMM_RESERVE_PRECISION)
         .div(numericConstants_1.FUNDING_PAYMENT_PRECISION)
         .mul(new __1.BN(-1));

package/lib/math/spotBalance.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="bn.js" />
+import { SpotMarketAccount, SpotBalanceType, MarginCategory } from '../types';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+export declare function getBalance(tokenAmount: BN, spotMarket: SpotMarketAccount, balanceType: SpotBalanceType): BN;
+export declare function getTokenAmount(balanceAmount: BN, spotMarket: SpotMarketAccount, balanceType: SpotBalanceType): BN;
+export declare function getSignedTokenAmount(tokenAmount: BN, balanceType: SpotBalanceType): BN;
+export declare function getTokenValue(tokenAmount: BN, spotDecimals: number, oraclePriceData: OraclePriceData): BN;
+export declare function calculateAssetWeight(balanceAmount: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function calculateLiabilityWeight(balanceAmount: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function calculateUtilization(bank: SpotMarketAccount): BN;
+export declare function calculateInterestRate(bank: SpotMarketAccount): BN;
+export declare function calculateDepositRate(bank: SpotMarketAccount): BN;
+export declare function calculateBorrowRate(bank: SpotMarketAccount): BN;
+export declare function calculateInterestAccumulated(bank: SpotMarketAccount, now: BN): {
+    borrowInterest: BN;
+    depositInterest: BN;
+};
+export declare function calculateWithdrawLimit(spotMarket: SpotMarketAccount, now: BN): {
+    borrowLimit: BN;
+    withdrawLimit: BN;
+};

package/lib/math/spotBalance.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWithdrawLimit = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateAssetWeight = exports.getTokenValue = exports.getSignedTokenAmount = exports.getTokenAmount = exports.getBalance = void 0;
+const types_1 = require("../types");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const margin_1 = require("./margin");
+function getBalance(tokenAmount, spotMarket, balanceType) {
+    const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - spotMarket.decimals));
+    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
+        ? spotMarket.cumulativeDepositInterest
+        : spotMarket.cumulativeBorrowInterest;
+    let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
+    if (!balance.eq(numericConstants_1.ZERO) && (0, types_1.isVariant)(balanceType, 'borrow')) {
+        balance = balance.add(numericConstants_1.ONE);
+    }
+    return balance;
+}
+exports.getBalance = getBalance;
+function getTokenAmount(balanceAmount, spotMarket, balanceType) {
+    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - spotMarket.decimals));
+    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
+        ? spotMarket.cumulativeDepositInterest
+        : spotMarket.cumulativeBorrowInterest;
+    return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
+}
+exports.getTokenAmount = getTokenAmount;
+function getSignedTokenAmount(tokenAmount, balanceType) {
+    if ((0, types_1.isVariant)(balanceType, 'deposit')) {
+        return tokenAmount;
+    }
+    else {
+        return tokenAmount.abs().neg();
+    }
+}
+exports.getSignedTokenAmount = getSignedTokenAmount;
+function getTokenValue(tokenAmount, spotDecimals, oraclePriceData) {
+    if (tokenAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(10 + spotDecimals - 6));
+    return tokenAmount.mul(oraclePriceData.price).div(precisionDecrease);
+}
+exports.getTokenValue = getTokenValue;
+function calculateAssetWeight(balanceAmount, spotMarket, marginCategory) {
+    const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(spotMarket.decimals));
+    let sizeInAmmReservePrecision;
+    if (sizePrecision.gt(numericConstants_1.AMM_RESERVE_PRECISION)) {
+        sizeInAmmReservePrecision = balanceAmount.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
+    }
+    else {
+        sizeInAmmReservePrecision = balanceAmount
+            .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+            .div(sizePrecision);
+    }
+    let assetWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, spotMarket.imfFactor, spotMarket.initialAssetWeight);
+            break;
+        case 'Maintenance':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, spotMarket.imfFactor, spotMarket.maintenanceAssetWeight);
+            break;
+        default:
+            assetWeight = spotMarket.initialAssetWeight;
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateAssetWeight = calculateAssetWeight;
+function calculateLiabilityWeight(balanceAmount, spotMarket, marginCategory) {
+    const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(spotMarket.decimals));
+    let sizeInAmmReservePrecision;
+    if (sizePrecision.gt(numericConstants_1.AMM_RESERVE_PRECISION)) {
+        sizeInAmmReservePrecision = balanceAmount.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
+    }
+    else {
+        sizeInAmmReservePrecision = balanceAmount
+            .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+            .div(sizePrecision);
+    }
+    let assetWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            assetWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, spotMarket.imfFactor, spotMarket.initialLiabilityWeight, numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            break;
+        case 'Maintenance':
+            assetWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, spotMarket.imfFactor, spotMarket.maintenanceLiabilityWeight, numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            break;
+        default:
+            assetWeight = spotMarket.initialLiabilityWeight;
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateLiabilityWeight = calculateLiabilityWeight;
+function calculateUtilization(bank) {
+    const tokenDepositAmount = getTokenAmount(bank.depositBalance, bank, types_1.SpotBalanceType.DEPOSIT);
+    const tokenBorrowAmount = getTokenAmount(bank.borrowBalance, bank, types_1.SpotBalanceType.BORROW);
+    let utilization;
+    if (tokenBorrowAmount.eq(numericConstants_1.ZERO) && tokenDepositAmount.eq(numericConstants_1.ZERO)) {
+        utilization = numericConstants_1.ZERO;
+    }
+    else if (tokenDepositAmount.eq(numericConstants_1.ZERO)) {
+        utilization = numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION;
+    }
+    else {
+        utilization = tokenBorrowAmount
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(tokenDepositAmount);
+    }
+    return utilization;
+}
+exports.calculateUtilization = calculateUtilization;
+function calculateInterestRate(bank) {
+    const utilization = calculateUtilization(bank);
+    let interestRate;
+    if (utilization.gt(bank.optimalUtilization)) {
+        const surplusUtilization = utilization.sub(bank.optimalUtilization);
+        const borrowRateSlope = bank.maxBorrowRate
+            .sub(bank.optimalBorrowRate)
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+        interestRate = bank.optimalBorrowRate.add(surplusUtilization
+            .mul(borrowRateSlope)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION));
+    }
+    else {
+        const borrowRateSlope = bank.optimalBorrowRate
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+        interestRate = utilization
+            .mul(borrowRateSlope)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    }
+    return interestRate;
+}
+exports.calculateInterestRate = calculateInterestRate;
+function calculateDepositRate(bank) {
+    const utilization = calculateUtilization(bank);
+    const borrowRate = calculateBorrowRate(bank);
+    const depositRate = borrowRate
+        .mul(utilization)
+        .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    return depositRate;
+}
+exports.calculateDepositRate = calculateDepositRate;
+function calculateBorrowRate(bank) {
+    return calculateInterestRate(bank);
+}
+exports.calculateBorrowRate = calculateBorrowRate;
+function calculateInterestAccumulated(bank, now) {
+    const interestRate = calculateInterestRate(bank);
+    const timeSinceLastUpdate = now.sub(bank.lastInterestTs);
+    const modifiedBorrowRate = interestRate.mul(timeSinceLastUpdate);
+    const utilization = calculateUtilization(bank);
+    const modifiedDepositRate = modifiedBorrowRate
+        .mul(utilization)
+        .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    const borrowInterest = bank.cumulativeBorrowInterest
+        .mul(modifiedBorrowRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .div(numericConstants_1.SPOT_MARKET_INTEREST_PRECISION)
+        .add(numericConstants_1.ONE);
+    const depositInterest = bank.cumulativeDepositInterest
+        .mul(modifiedDepositRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .div(numericConstants_1.SPOT_MARKET_INTEREST_PRECISION);
+    return { borrowInterest, depositInterest };
+}
+exports.calculateInterestAccumulated = calculateInterestAccumulated;
+function calculateWithdrawLimit(spotMarket, now) {
+    const marketDepositTokenAmount = getTokenAmount(spotMarket.depositBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    const marketBorrowTokenAmount = getTokenAmount(spotMarket.borrowBalance, spotMarket, types_1.SpotBalanceType.BORROW);
+    const twentyFourHours = new anchor_1.BN(60 * 60 * 24);
+    const sinceLast = now.sub(spotMarket.lastTwapTs);
+    const sinceStart = anchor_1.BN.max(numericConstants_1.ZERO, twentyFourHours.sub(sinceLast));
+    const borrowTokenTwapLive = spotMarket.borrowTokenTwap
+        .mul(sinceStart)
+        .add(marketBorrowTokenAmount.mul(sinceLast))
+        .div(sinceLast.add(sinceLast));
+    const depositTokenTwapLive = spotMarket.depositTokenTwap
+        .mul(sinceStart)
+        .add(marketDepositTokenAmount.mul(sinceLast))
+        .div(sinceLast.add(sinceLast));
+    const maxBorrowTokens = anchor_1.BN.min(anchor_1.BN.max(marketDepositTokenAmount.div(new anchor_1.BN(6)), borrowTokenTwapLive.add(borrowTokenTwapLive.div(new anchor_1.BN(5)))), marketDepositTokenAmount.sub(marketDepositTokenAmount.div(new anchor_1.BN(10)))); // between ~15-90% utilization with friction on twap
+    const minDepositTokens = depositTokenTwapLive.sub(anchor_1.BN.min(anchor_1.BN.max(depositTokenTwapLive.div(new anchor_1.BN(5)), spotMarket.withdrawGuardThreshold), depositTokenTwapLive));
+    return {
+        borrowLimit: maxBorrowTokens.sub(marketBorrowTokenAmount),
+        withdrawLimit: marketDepositTokenAmount.sub(minDepositTokens),
+    };
+}
+exports.calculateWithdrawLimit = calculateWithdrawLimit;

package/lib/math/spotMarket.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="bn.js" />
+import { BN } from '@project-serum/anchor';
+import { SpotMarketAccount } from '../types';
+export declare function castNumberToSpotPrecision(value: number, spotMarket: SpotMarketAccount): BN;

package/lib/math/spotMarket.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.castNumberToSpotPrecision = void 0;
+const anchor_1 = require("@project-serum/anchor");
+function castNumberToSpotPrecision(value, spotMarket) {
+    return new anchor_1.BN(value * Math.pow(10, spotMarket.decimals));
+}
+exports.castNumberToSpotPrecision = castNumberToSpotPrecision;

package/lib/math/spotPosition.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="bn.js" />
+import { SpotMarketAccount, SpotPosition } from '../types';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+export declare function isSpotPositionAvailable(position: SpotPosition): boolean;
+export declare function getWorstCaseTokenAmounts(spotPosition: SpotPosition, spotMarketAccount: SpotMarketAccount, oraclePriceData: OraclePriceData): [BN, BN];

package/lib/math/spotPosition.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorstCaseTokenAmounts = exports.isSpotPositionAvailable = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const spotBalance_1 = require("./spotBalance");
+function isSpotPositionAvailable(position) {
+    return position.balance.eq(numericConstants_1.ZERO) && position.openOrders === 0;
+}
+exports.isSpotPositionAvailable = isSpotPositionAvailable;
+function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, oraclePriceData) {
+    const tokenAmount = (0, spotBalance_1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
+    const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
+    const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
+    if (tokenAmountAllAsksFill.abs().gt(tokenAmountAllBidsFill.abs())) {
+        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
+        return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
+    }
+    else {
+        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
+        return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
+    }
+}
+exports.getWorstCaseTokenAmounts = getWorstCaseTokenAmounts;

package/lib/math/state.js

@@ -8,8 +8,8 @@ exports.getExchangeFee = void 0;
  * @returns Precision : basis points (bps)
  */
 function getExchangeFee(state) {
-    const exchangeFee = state.feeStructure.feeNumerator.toNumber() /
-        state.feeStructure.feeDenominator.toNumber();
+    const exchangeFee = state.perpFeeStructure.feeNumerator.toNumber() /
+        state.perpFeeStructure.feeDenominator.toNumber();
     return exchangeFee;
 }
 exports.getExchangeFee = getExchangeFee;

package/lib/math/trade.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="bn.js" />
-import { MarketAccount, PositionDirection } from '../types';
+import { PerpMarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { AssetType } from './amm';
 import { OraclePriceData } from '../oracles/types';
@@ -21,7 +21,7 @@ export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' |
  *
  * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
  */
-export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: MarketAccount, inputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [BN, BN, BN, BN];
+export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: PerpMarketAccount, inputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [BN, BN, BN, BN];
 /**
  * Calculates acquired amounts for trade executed
  * @param direction
@@ -33,7 +33,7 @@ export declare function calculateTradeSlippage(direction: PositionDirection, amo
  * 	| 'acquiredBase' =>  positive/negative change in user's base : BN AMM_RESERVE_PRECISION
  * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
  */
-export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: MarketAccount, inputAssetType: AssetType, oraclePriceData: OraclePriceData, useSpread?: boolean): [BN, BN, BN];
+export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: PerpMarketAccount, inputAssetType: AssetType, oraclePriceData: OraclePriceData, useSpread?: boolean): [BN, BN, BN];
 /**
  * calculateTargetPriceTrade
  * simple function for finding arbitraging trades
@@ -51,4 +51,4 @@ export declare function calculateTradeAcquiredAmounts(direction: PositionDirecti
  *   targetPrice => the target price MARK_PRICE_PRECISION
  * ]
  */
-export declare function calculateTargetPriceTrade(market: MarketAccount, targetPrice: BN, pct?: BN, outputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [PositionDirection, BN, BN, BN];
+export declare function calculateTargetPriceTrade(market: PerpMarketAccount, targetPrice: BN, pct?: BN, outputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [PositionDirection, BN, BN, BN];

package/lib/orderParams.d.ts

@@ -1,16 +1,16 @@
 /// <reference types="bn.js" />
 import { OptionalOrderParams, OrderTriggerCondition } from './types';
 import { BN } from '@project-serum/anchor';
-export declare function getLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+export declare function getLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
     price: BN;
 }): OptionalOrderParams;
-export declare function getTriggerMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+export declare function getTriggerMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
     triggerCondition: OrderTriggerCondition;
     triggerPrice: BN;
 }): OptionalOrderParams;
-export declare function getTriggerLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType'> & {
+export declare function getTriggerLimitOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
     triggerCondition: OrderTriggerCondition;
     triggerPrice: BN;
     price: BN;
 }): OptionalOrderParams;
-export declare function getMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType'>): OptionalOrderParams;
+export declare function getMarketOrderParams(params: Omit<OptionalOrderParams, 'orderType' | 'marketType'>): OptionalOrderParams;

package/lib/orderParams.js

@@ -3,18 +3,26 @@ 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 });
+    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 });
+    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 });
+    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 });
+    return Object.assign({}, params, {
+        orderType: types_1.OrderType.MARKET,
+    });
 }
 exports.getMarketOrderParams = getMarketOrderParams;

package/lib/serum/serumSubscriber.d.ts

@@ -0,0 +1,23 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import { Market, Orderbook } from '@project-serum/serum';
+import { SerumMarketSubscriberConfig } from './types';
+export declare class SerumSubscriber {
+    connection: Connection;
+    programId: PublicKey;
+    marketAddress: PublicKey;
+    accountLoader: BulkAccountLoader;
+    market: Market;
+    subscribed: boolean;
+    asksAddress: PublicKey;
+    asks: Orderbook;
+    asksCallbackId: string;
+    lastAsksSlot: number;
+    bidsAddress: PublicKey;
+    bids: Orderbook;
+    bidsCallbackId: string;
+    lastBidsSlot: number;
+    constructor(config: SerumMarketSubscriberConfig);
+    subscribe(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/serum/serumSubscriber.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerumSubscriber = void 0;
+const serum_1 = require("@project-serum/serum");
+class SerumSubscriber {
+    constructor(config) {
+        this.connection = config.connection;
+        this.programId = config.programId;
+        this.marketAddress = config.marketAddress;
+        this.accountLoader = config.accountSubscription.accountLoader;
+    }
+    async subscribe() {
+        if (this.subscribed) {
+            return;
+        }
+        this.market = await serum_1.Market.load(this.connection, this.marketAddress, undefined, this.programId);
+        this.asksAddress = this.market.asksAddress;
+        this.asks = await this.market.loadAsks(this.connection);
+        this.asksCallbackId = this.accountLoader.addAccount(this.asksAddress, (buffer, slot) => {
+            this.lastAsksSlot = slot;
+            this.asks = serum_1.Orderbook.decode(this.market, buffer);
+            console.log(this.asks.getL2(3));
+        });
+        this.bidsAddress = this.market.bidsAddress;
+        this.bids = await this.market.loadBids(this.connection);
+        this.bidsCallbackId = this.accountLoader.addAccount(this.bidsAddress, (buffer, slot) => {
+            this.lastBidsSlot = slot;
+            this.bids = serum_1.Orderbook.decode(this.market, buffer);
+        });
+        this.subscribed = true;
+    }
+    async unsubscribe() {
+        if (!this.subscribed) {
+            return;
+        }
+        this.accountLoader.removeAccount(this.asksAddress, this.asksCallbackId);
+        this.accountLoader.removeAccount(this.bidsAddress, this.bidsCallbackId);
+        this.subscribed = false;
+    }
+}
+exports.SerumSubscriber = SerumSubscriber;

package/lib/serum/types.d.ts

@@ -0,0 +1,11 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+export declare type SerumMarketSubscriberConfig = {
+    connection: Connection;
+    programId: PublicKey;
+    marketAddress: PublicKey;
+    accountSubscription: {
+        type: 'polling';
+        accountLoader: BulkAccountLoader;
+    };
+};

package/lib/serum/types.js

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

package/lib/tx/retryTxSender.d.ts

@@ -11,7 +11,7 @@ export declare class RetryTxSender implements TxSender {
     retrySleep: number;
     additionalConnections: Connection[];
     constructor(provider: AnchorProvider, timeout?: number, retrySleep?: number, additionalConnections?: Connection[]);
-    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TxSigAndSlot>;
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
     confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
     getTimestamp(): number;

package/lib/tx/retryTxSender.js

@@ -15,14 +15,16 @@ class RetryTxSender {
         this.retrySleep = retrySleep !== null && retrySleep !== void 0 ? retrySleep : DEFAULT_RETRY;
         this.additionalConnections = additionalConnections;
     }
-    async send(tx, additionalSigners, opts) {
+    async send(tx, additionalSigners, opts, preSigned) {
         if (additionalSigners === undefined) {
             additionalSigners = [];
         }
         if (opts === undefined) {
             opts = this.provider.opts;
         }
-        await this.prepareTx(tx, additionalSigners, opts);
+        if (!preSigned) {
+            await this.prepareTx(tx, additionalSigners, opts);
+        }
         const rawTransaction = tx.serialize();
         const startTime = this.getTimestamp();
         let txid;

package/lib/tx/types.d.ts

@@ -6,5 +6,5 @@ export declare type TxSigAndSlot = {
 };
 export interface TxSender {
     provider: Provider;
-    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TxSigAndSlot>;
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
 }