@drift-labs/sdk 0.1.36-master.4 → 0.1.36-master.7

package/lib/index.d.ts

@@ -25,6 +25,7 @@ export * from './math/funding';
 export * from './math/insuranceFund';
 export * from './math/market';
 export * from './math/position';
+export * from './math/oracles';
 export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';

package/lib/index.js

@@ -44,6 +44,7 @@ __exportStar(require("./math/funding"), exports);
 __exportStar(require("./math/insuranceFund"), exports);
 __exportStar(require("./math/market"), exports);
 __exportStar(require("./math/position"), exports);
+__exportStar(require("./math/oracles"), exports);
 __exportStar(require("./math/amm"), exports);
 __exportStar(require("./math/trade"), exports);
 __exportStar(require("./math/orders"), exports);

package/lib/math/oracles.d.ts

@@ -0,0 +1,3 @@
+import { AMM, OracleGuardRails } from '../types';
+import { OraclePriceData } from '../oracles/types';
+export declare function isOracleValid(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, slot: number): boolean;

package/lib/math/oracles.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOracleValid = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const index_1 = require("../index");
+function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
+    const isOraclePriceNonPositive = oraclePriceData.price.lt(numericConstants_1.ZERO);
+    const isOraclePriceTooVolatile = oraclePriceData.price
+        .div(index_1.BN.max(numericConstants_1.ONE, amm.lastOraclePriceTwap))
+        .gt(oracleGuardRails.validity.tooVolatileRatio) ||
+        amm.lastOraclePriceTwap
+            .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.price))
+            .gt(oracleGuardRails.validity.tooVolatileRatio);
+    const isConfidenceTooLarge = oraclePriceData.price
+        .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.confidence))
+        .lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+    const oracleIsStale = oraclePriceData.slot
+        .sub(new index_1.BN(slot))
+        .gt(oracleGuardRails.validity.slotsBeforeStale);
+    return !(!oraclePriceData.hasSufficientNumberOfDataPoints ||
+        oracleIsStale ||
+        isOraclePriceNonPositive ||
+        isOraclePriceTooVolatile ||
+        isConfidenceTooLarge);
+}
+exports.isOracleValid = isOracleValid;

package/lib/math/position.d.ts

@@ -18,6 +18,7 @@ export declare function calculateBaseAssetValue(market: Market, userPosition: Us
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 export declare function calculatePositionPNL(market: Market, marketPosition: UserPosition, withFunding?: boolean): BN;
+export declare function calculateSettledPositionPNL(market: Market, marketPosition: UserPosition): BN;
 /**
  *
  * @param market

package/lib/math/position.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.calculatePositionFundingPNL = exports.calculateSettledPositionPNL = 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");
+const settlement_1 = require("../settlement");
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -60,6 +61,23 @@ function calculatePositionPNL(market, marketPosition, withFunding = false) {
     return pnl;
 }
 exports.calculatePositionPNL = calculatePositionPNL;
+function calculateSettledPositionPNL(market, marketPosition) {
+    let pnl = calculatePositionPNL(market, marketPosition);
+    if (pnl.gt(numericConstants_1.ZERO)) {
+        try {
+            pnl = pnl
+                .mul(new __1.BN(settlement_1.SETTLEMENT_RATIOS[marketPosition.marketIndex.toNumber()]))
+                .div(settlement_1.SETTLEMENT_RATIO_PRECISION);
+        }
+        catch (e) {
+            console.log(pnl.toString());
+            console.log(marketPosition.marketIndex.toNumber());
+            throw e;
+        }
+    }
+    return pnl;
+}
+exports.calculateSettledPositionPNL = calculateSettledPositionPNL;
 /**
  *
  * @param market

package/lib/math/trade.d.ts

@@ -8,6 +8,8 @@ export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' |
  * @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
@@ -18,7 +20,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: Market, inputAssetType?: AssetType): [BN, BN, BN, BN];
+export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: Market, inputAssetType?: AssetType, useSpread?: boolean): [BN, BN, BN, BN];
 /**
  * Calculates acquired amounts for trade executed
  * @param direction
@@ -27,7 +29,7 @@ export declare function calculateTradeSlippage(direction: PositionDirection, amo
  * @param inputAssetType
  * @param useSpread
  * @return
- * 	| 'acquiredBase' =>  positive/negative change in user's base : BN TODO-PRECISION
+ * 	| '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: Market, inputAssetType?: AssetType, useSpread?: boolean): [BN, BN];
@@ -37,13 +39,15 @@ export declare function calculateTradeAcquiredAmounts(direction: PositionDirecti
  * @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, TODO-PRECISION
+ *   direction => direction of trade required, PositionDirection
  *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, TODO-PRECISION
- *   targetPrice => the target price TODO-PRECISION
+ *   entryPrice => the entry price for the trade, MARK_PRICE_PRECISION
+ *   targetPrice => the target price MARK_PRICE_PRECISION
  * ]
  */
-export declare function calculateTargetPriceTrade(market: Market, targetPrice: BN, pct?: BN, outputAssetType?: AssetType): [PositionDirection, BN, BN, BN];
+export declare function calculateTargetPriceTrade(market: Market, targetPrice: BN, pct?: BN, outputAssetType?: AssetType, useSpread?: boolean): [PositionDirection, BN, BN, BN];

package/lib/math/trade.js

@@ -8,12 +8,15 @@ 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
@@ -24,14 +27,38 @@ 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') {
-    const oldPrice = (0, market_1.calculateMarkPrice)(market);
+function calculateTradeSlippage(direction, amount, market, inputAssetType = 'quote', useSpread = true) {
+    let oldPrice;
+    if (useSpread && market.amm.baseSpread > 0) {
+        if ((0, types_2.isVariant)(direction, 'long')) {
+            oldPrice = (0, market_1.calculateAskPrice)(market);
+        }
+        else {
+            oldPrice = (0, market_1.calculateBidPrice)(market);
+        }
+    }
+    else {
+        oldPrice = (0, market_1.calculateMarkPrice)(market);
+    }
     if (amount.eq(numericConstants_1.ZERO)) {
         return [numericConstants_1.ZERO, numericConstants_1.ZERO, oldPrice, oldPrice];
     }
-    const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType);
+    const [acquiredBase, acquiredQuote] = calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType, useSpread);
     const entryPrice = (0, amm_1.calculatePrice)(acquiredBase, acquiredQuote, market.amm.pegMultiplier).mul(new anchor_1.BN(-1));
-    const newPrice = (0, amm_1.calculatePrice)(market.amm.baseAssetReserve.sub(acquiredBase), market.amm.quoteAssetReserve.sub(acquiredQuote), market.amm.pegMultiplier);
+    let amm;
+    if (useSpread && market.amm.baseSpread > 0) {
+        const { baseAssetReserve, quoteAssetReserve } = (0, amm_1.calculateSpreadReserves)(market.amm, direction);
+        amm = {
+            baseAssetReserve,
+            quoteAssetReserve,
+            sqrtK: market.amm.sqrtK,
+            pegMultiplier: market.amm.pegMultiplier,
+        };
+    }
+    else {
+        amm = market.amm;
+    }
+    const newPrice = (0, amm_1.calculatePrice)(amm.baseAssetReserve.sub(acquiredBase), amm.quoteAssetReserve.sub(acquiredQuote), amm.pegMultiplier);
     if (direction == types_1.PositionDirection.SHORT) {
         (0, assert_1.assert)(newPrice.lt(oldPrice));
     }
@@ -59,7 +86,7 @@ exports.calculateTradeSlippage = calculateTradeSlippage;
  * @param inputAssetType
  * @param useSpread
  * @return
- * 	| 'acquiredBase' =>  positive/negative change in user's base : BN TODO-PRECISION
+ * 	| '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', useSpread = true) {
@@ -92,35 +119,50 @@ exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
  * @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, TODO-PRECISION
+ *   direction => direction of trade required, PositionDirection
  *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, TODO-PRECISION
- *   targetPrice => the target price 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') {
+function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAssetType = 'quote', 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));
     const markPriceBefore = (0, market_1.calculateMarkPrice)(market);
+    const bidPriceBefore = (0, market_1.calculateBidPrice)(market);
+    const askPriceBefore = (0, market_1.calculateAskPrice)(market);
+    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 direction;
     let tradeSize;
     let baseSize;
-    const baseAssetReserveBefore = market.amm.baseAssetReserve;
-    const quoteAssetReserveBefore = market.amm.quoteAssetReserve;
+    let baseAssetReserveBefore;
+    let quoteAssetReserveBefore;
+    if (useSpread && market.amm.baseSpread > 0) {
+        const { baseAssetReserve, quoteAssetReserve } = (0, amm_1.calculateSpreadReserves)(market.amm, direction);
+        baseAssetReserveBefore = baseAssetReserve;
+        quoteAssetReserveBefore = quoteAssetReserve;
+    }
+    else {
+        baseAssetReserveBefore = market.amm.baseAssetReserve;
+        quoteAssetReserveBefore = market.amm.quoteAssetReserve;
+    }
     const peg = market.amm.pegMultiplier;
     const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
     const k = invariant.mul(numericConstants_1.MARK_PRICE_PRECISION);
@@ -128,7 +170,20 @@ function calculateTargetPriceTrade(market, targetPrice, pct = MAXPCT, outputAsse
     let quoteAssetReserveAfter;
     const biasModifier = new anchor_1.BN(1);
     let markPriceAfter;
-    if (markPriceBefore.gt(targetPrice)) {
+    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 = (0, utils_1.squareRootBN)(k.div(targetPrice).mul(peg).div(numericConstants_1.PEG_PRECISION).sub(biasModifier)).sub(new anchor_1.BN(1));
         quoteAssetReserveAfter = k

package/lib/oracles/pythClient.js

@@ -38,6 +38,7 @@ class PythClient {
                 confidence: convertPythPrice(priceData.confidence, priceData.exponent),
                 twap: convertPythPrice(priceData.twap.value, priceData.exponent),
                 twapConfidence: convertPythPrice(priceData.twac.value, priceData.exponent),
+                hasSufficientNumberOfDataPoints: true,
             };
         });
     }

package/lib/oracles/switchboardClient.js

@@ -39,11 +39,14 @@ class SwitchboardClient {
             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,
             };
         });
     }

package/lib/oracles/types.d.ts

@@ -6,6 +6,7 @@ export declare type OraclePriceData = {
     price: BN;
     slot: BN;
     confidence: BN;
+    hasSufficientNumberOfDataPoints: boolean;
     twap?: BN;
     twapConfidence?: BN;
 };

package/lib/settlement.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="bn.js" />
+import { BN } from '@project-serum/anchor';
+export declare const SETTLEMENT_RATIO_PRECISION: BN;
+export declare const SETTLEMENT_RATIOS: number[];

package/lib/settlement.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SETTLEMENT_RATIOS = exports.SETTLEMENT_RATIO_PRECISION = void 0;
+const anchor_1 = require("@project-serum/anchor");
+exports.SETTLEMENT_RATIO_PRECISION = new anchor_1.BN(1000000);
+exports.SETTLEMENT_RATIOS = [
+    291786, 243613, 712271, 293771, 555181, 604938, 241133, 218489, 251741,
+    883058, 51614, 531737, 956092, 106424, 727107, 477277, 217325, 127477, 248561,
+    565938, 59349,
+];

package/lib/types.d.ts

@@ -275,6 +275,12 @@ export declare type OrderStateAccount = {
     orderFillerRewardStructure: OrderFillerRewardStructure;
     minOrderQuoteAssetAmount: BN;
 };
+export declare type SettlementStateAccount = {
+    totalSettlementValue: BN;
+    collateralAvailableToClaim: BN;
+    collateralClaimed: BN;
+    enabled: boolean;
+};
 export declare type MarketsAccount = {
     markets: Market[];
 };
@@ -337,6 +343,11 @@ export declare type UserAccount = {
     totalTokenDiscount: BN;
     totalReferralReward: BN;
     totalRefereeDiscount: BN;
+    settledPositionValue: BN;
+    collateralClaimed: BN;
+    lastCollateralAvailableToClaim: BN;
+    forgoPositionSettlement: number;
+    hasSettledPosition: number;
 };
 export declare type UserOrdersAccount = {
     orders: Order[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.36-master.4",
+	"version": "0.1.36-master.7",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/bulkAccountLoader.ts

@@ -24,6 +24,7 @@ export class BulkAccountLoader {
 	loadPromise?: Promise<void>;
 	loadPromiseResolver: () => void;
 	lastTimeLoadingPromiseCleared = Date.now();
+	mostRecentSlot = 0;
 
 	public constructor(
 		connection: Connection,
@@ -159,6 +160,10 @@ export class BulkAccountLoader {
 
 		const newSlot = rpcResponse.result.context.slot;
 
+		if (newSlot > this.mostRecentSlot) {
+			this.mostRecentSlot = newSlot;
+		}
+
 		for (const i in accountsToLoad) {
 			const accountToLoad = accountsToLoad[i];
 			const key = accountToLoad.publicKey.toString();

package/src/addresses.ts

@@ -69,3 +69,14 @@ export async function getUserOrdersAccountPublicKey(
 		await getUserOrdersAccountPublicKeyAndNonce(programId, userAccount)
 	)[0];
 }
+
+export async function getSettlementStatePublicKey(
+	programId: PublicKey
+): Promise<PublicKey> {
+	return (
+		await anchor.web3.PublicKey.findProgramAddress(
+			[Buffer.from(anchor.utils.bytes.utf8.encode('settlement_state'))],
+			programId
+		)
+	)[0];
+}

package/src/admin.ts

@@ -18,6 +18,8 @@ import {
 	getClearingHouseStateAccountPublicKey,
 	getClearingHouseStateAccountPublicKeyAndNonce,
 	getOrderStateAccountPublicKeyAndNonce,
+	getSettlementStatePublicKey,
+	getUserAccountPublicKey,
 } from './addresses';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { ClearingHouse } from './clearingHouse';
@@ -733,4 +735,85 @@ export class Admin extends ClearingHouse {
 			},
 		});
 	}
+
+	public async transferFromInsuranceVaultToCollateralVault(): Promise<TransactionSignature> {
+		const state = await this.getStateAccount();
+		return await this.program.rpc.transferFromInsuranceVaultToCollateralVault({
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				insuranceVault: state.insuranceVault,
+				insuranceVaultAuthority: state.insuranceVaultAuthority,
+				collateralVault: state.collateralVault,
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+		});
+	}
+
+	public async adminUpdateUserForgoSettlement(
+		authority: PublicKey
+	): Promise<TransactionSignature> {
+		const user = await getUserAccountPublicKey(
+			this.program.programId,
+			authority
+		);
+
+		return await this.program.rpc.adminUpdateUserForgoSettlement({
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				user: user,
+			},
+		});
+	}
+
+	public async initializeSettlementState(): Promise<TransactionSignature> {
+		const settlementState = await getSettlementStatePublicKey(
+			this.program.programId
+		);
+
+		const settlementSize = await this.getTotalSettlementSize();
+
+		return await this.program.rpc.initializeSettlementState(settlementSize, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				settlementState: settlementState,
+				rent: SYSVAR_RENT_PUBKEY,
+				systemProgram: anchor.web3.SystemProgram.programId,
+				collateralVault: (await this.getStateAccount()).collateralVault,
+			},
+		});
+	}
+
+	public async updateSettlementState(): Promise<TransactionSignature> {
+		const settlementState = await getSettlementStatePublicKey(
+			this.program.programId
+		);
+
+		return await this.program.rpc.updateSettlementState({
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				settlementState: settlementState,
+				collateralVault: (await this.getStateAccount()).collateralVault,
+			},
+		});
+	}
+
+	public async updateSettlementStateEnabled(
+		enabled: boolean
+	): Promise<TransactionSignature> {
+		const settlementState = await getSettlementStatePublicKey(
+			this.program.programId
+		);
+
+		return await this.program.rpc.updateSettlementStateEnabled(enabled, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				settlementState: settlementState,
+			},
+		});
+	}
 }