@drift-labs/sdk 2.37.1-beta.0 → 2.37.1-beta.10

package/lib/user.js

@@ -145,6 +145,7 @@ class User {
             lpShares: numericConstants_1.ZERO,
             lastBaseAssetAmountPerLp: numericConstants_1.ZERO,
             lastQuoteAssetAmountPerLp: numericConstants_1.ZERO,
+            perLpBase: 0,
         };
     }
     getClonedPosition(position) {
@@ -258,17 +259,54 @@ class User {
         }
         const position = this.getClonedPosition(originalPosition);
         const market = this.driftClient.getPerpMarketAccount(position.marketIndex);
+        if (market.amm.perLpBase != position.perLpBase) {
+            // perLpBase = 1 => per 10 LP shares, perLpBase = -1 => per 0.1 LP shares
+            const expoDiff = market.amm.perLpBase - position.perLpBase;
+            const marketPerLpRebaseScalar = new _1.BN(10 ** Math.abs(expoDiff));
+            if (expoDiff > 0) {
+                position.lastBaseAssetAmountPerLp =
+                    position.lastBaseAssetAmountPerLp.mul(marketPerLpRebaseScalar);
+                position.lastQuoteAssetAmountPerLp =
+                    position.lastQuoteAssetAmountPerLp.mul(marketPerLpRebaseScalar);
+            }
+            else {
+                position.lastBaseAssetAmountPerLp =
+                    position.lastBaseAssetAmountPerLp.div(marketPerLpRebaseScalar);
+                position.lastQuoteAssetAmountPerLp =
+                    position.lastQuoteAssetAmountPerLp.div(marketPerLpRebaseScalar);
+            }
+            position.perLpBase = position.perLpBase + expoDiff;
+        }
         const nShares = position.lpShares;
         // incorp unsettled funding on pre settled position
         const quoteFundingPnl = (0, _1.calculatePositionFundingPNL)(market, position);
+        let baseUnit = numericConstants_1.AMM_RESERVE_PRECISION;
+        if (market.amm.perLpBase == position.perLpBase) {
+            if (position.perLpBase >= 0 &&
+                position.perLpBase <= numericConstants_1.AMM_RESERVE_PRECISION_EXP.toNumber()) {
+                const marketPerLpRebase = new _1.BN(10 ** market.amm.perLpBase);
+                baseUnit = baseUnit.mul(marketPerLpRebase);
+            }
+            else if (position.perLpBase < 0 &&
+                position.perLpBase >= -numericConstants_1.AMM_RESERVE_PRECISION_EXP.toNumber()) {
+                const marketPerLpRebase = new _1.BN(10 ** Math.abs(market.amm.perLpBase));
+                baseUnit = baseUnit.div(marketPerLpRebase);
+            }
+            else {
+                throw 'cannot calc';
+            }
+        }
+        else {
+            throw 'market.amm.perLpBase != position.perLpBase';
+        }
         const deltaBaa = market.amm.baseAssetAmountPerLp
             .sub(position.lastBaseAssetAmountPerLp)
             .mul(nShares)
-            .div(numericConstants_1.AMM_RESERVE_PRECISION);
+            .div(baseUnit);
         const deltaQaa = market.amm.quoteAssetAmountPerLp
             .sub(position.lastQuoteAssetAmountPerLp)
             .mul(nShares)
-            .div(numericConstants_1.AMM_RESERVE_PRECISION);
+            .div(baseUnit);
         function sign(v) {
             return v.isNeg() ? new _1.BN(-1) : new _1.BN(1);
         }
@@ -464,7 +502,7 @@ class User {
             }
             positionUnrealizedPnl = positionUnrealizedPnl
                 .mul(quotePrice)
-                .div(new _1.BN(numericConstants_1.PRICE_PRECISION));
+                .div(numericConstants_1.PRICE_PRECISION);
             if (withWeightMarginCategory !== undefined) {
                 if (positionUnrealizedPnl.gt(numericConstants_1.ZERO)) {
                     positionUnrealizedPnl = positionUnrealizedPnl
@@ -660,64 +698,81 @@ class User {
         }
         return health;
     }
+    calculateWeightedPerpPositionValue(perpPosition, marginCategory, liquidationBuffer, includeOpenOrders, strict = false) {
+        const market = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
+        if (perpPosition.lpShares.gt(numericConstants_1.ZERO)) {
+            // is an lp, clone so we dont mutate the position
+            perpPosition = this.getPerpPositionWithLPSettle(market.marketIndex, this.getClonedPosition(perpPosition), !!marginCategory)[0];
+        }
+        let valuationPrice = this.getOracleDataForPerpMarket(market.marketIndex).price;
+        if ((0, types_1.isVariant)(market.status, 'settlement')) {
+            valuationPrice = market.expiryPrice;
+        }
+        const baseAssetAmount = includeOpenOrders
+            ? (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition)
+            : perpPosition.baseAssetAmount;
+        let baseAssetValue = baseAssetAmount
+            .abs()
+            .mul(valuationPrice)
+            .div(numericConstants_1.BASE_PRECISION);
+        if (marginCategory) {
+            let marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), marginCategory));
+            if (marginCategory === 'Initial') {
+                marginRatio = _1.BN.max(marginRatio, new _1.BN(this.getUserAccount().maxMarginRatio));
+            }
+            if (liquidationBuffer !== undefined) {
+                marginRatio = marginRatio.add(liquidationBuffer);
+            }
+            if ((0, types_1.isVariant)(market.status, 'settlement')) {
+                marginRatio = numericConstants_1.ZERO;
+            }
+            const quoteSpotMarket = this.driftClient.getSpotMarketAccount(market.quoteSpotMarketIndex);
+            const quoteOraclePriceData = this.driftClient.getOraclePriceDataAndSlot(quoteSpotMarket.oracle).data;
+            let quotePrice;
+            if (strict) {
+                quotePrice = _1.BN.max(quoteOraclePriceData.price, quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min);
+            }
+            else {
+                quotePrice = quoteOraclePriceData.price;
+            }
+            baseAssetValue = baseAssetValue
+                .mul(quotePrice)
+                .div(numericConstants_1.PRICE_PRECISION)
+                .mul(marginRatio)
+                .div(numericConstants_1.MARGIN_PRECISION);
+            if (includeOpenOrders) {
+                baseAssetValue = baseAssetValue.add(new _1.BN(perpPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT));
+                if (perpPosition.lpShares.gt(numericConstants_1.ZERO)) {
+                    baseAssetValue = baseAssetValue.add(_1.BN.max(numericConstants_1.QUOTE_PRECISION, valuationPrice
+                        .mul(market.amm.orderStepSize)
+                        .mul(numericConstants_1.QUOTE_PRECISION)
+                        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+                        .div(numericConstants_1.PRICE_PRECISION)));
+                }
+            }
+        }
+        return baseAssetValue;
+    }
+    /**
+     * calculates position value of a single perp market in margin system
+     * @returns : Precision QUOTE_PRECISION
+     */
+    getPerpMarketLiabilityValue(marketIndex, marginCategory, liquidationBuffer, includeOpenOrders, strict = false) {
+        const perpPosition = this.getPerpPosition(marketIndex);
+        if (!perpPosition) {
+            return numericConstants_1.ZERO;
+        }
+        else {
+            return this.calculateWeightedPerpPositionValue(perpPosition, marginCategory, liquidationBuffer, includeOpenOrders, strict);
+        }
+    }
     /**
      * calculates sum of position value across all positions in margin system
      * @returns : Precision QUOTE_PRECISION
      */
     getTotalPerpPositionValue(marginCategory, liquidationBuffer, includeOpenOrders, strict = false) {
         return this.getActivePerpPositions().reduce((totalPerpValue, perpPosition) => {
-            const market = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
-            if (perpPosition.lpShares.gt(numericConstants_1.ZERO)) {
-                // is an lp, clone so we dont mutate the position
-                perpPosition = this.getPerpPositionWithLPSettle(market.marketIndex, this.getClonedPosition(perpPosition), !!marginCategory)[0];
-            }
-            let valuationPrice = this.getOracleDataForPerpMarket(market.marketIndex).price;
-            if ((0, types_1.isVariant)(market.status, 'settlement')) {
-                valuationPrice = market.expiryPrice;
-            }
-            const baseAssetAmount = includeOpenOrders
-                ? (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition)
-                : perpPosition.baseAssetAmount;
-            let baseAssetValue = baseAssetAmount
-                .abs()
-                .mul(valuationPrice)
-                .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.PRICE_PRECISION));
-            if (marginCategory) {
-                let marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(market, baseAssetAmount.abs(), marginCategory));
-                if (marginCategory === 'Initial') {
-                    marginRatio = _1.BN.max(marginRatio, new _1.BN(this.getUserAccount().maxMarginRatio));
-                }
-                if (liquidationBuffer !== undefined) {
-                    marginRatio = marginRatio.add(liquidationBuffer);
-                }
-                if ((0, types_1.isVariant)(market.status, 'settlement')) {
-                    marginRatio = numericConstants_1.ZERO;
-                }
-                const quoteSpotMarket = this.driftClient.getSpotMarketAccount(market.quoteSpotMarketIndex);
-                const quoteOraclePriceData = this.driftClient.getOraclePriceDataAndSlot(quoteSpotMarket.oracle).data;
-                let quotePrice;
-                if (strict) {
-                    quotePrice = _1.BN.max(quoteOraclePriceData.price, quoteSpotMarket.historicalOracleData.lastOraclePriceTwap5Min);
-                }
-                else {
-                    quotePrice = quoteOraclePriceData.price;
-                }
-                baseAssetValue = baseAssetValue
-                    .mul(quotePrice)
-                    .div(numericConstants_1.PRICE_PRECISION)
-                    .mul(marginRatio)
-                    .div(numericConstants_1.MARGIN_PRECISION);
-                if (includeOpenOrders) {
-                    baseAssetValue = baseAssetValue.add(new _1.BN(perpPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT));
-                    if (perpPosition.lpShares.gt(numericConstants_1.ZERO)) {
-                        baseAssetValue = baseAssetValue.add(_1.BN.max(numericConstants_1.QUOTE_PRECISION, valuationPrice
-                            .mul(market.amm.orderStepSize)
-                            .mul(numericConstants_1.QUOTE_PRECISION)
-                            .div(numericConstants_1.AMM_RESERVE_PRECISION)
-                            .div(numericConstants_1.PRICE_PRECISION)));
-                    }
-                }
-            }
+            const baseAssetValue = this.calculateWeightedPerpPositionValue(perpPosition, marginCategory, liquidationBuffer, includeOpenOrders, strict);
             return totalPerpValue.add(baseAssetValue);
         }, numericConstants_1.ZERO);
     }
@@ -1589,12 +1644,15 @@ class User {
         if (canBypass) {
             withdrawLimit = _1.BN.max(withdrawLimit, userDepositAmount);
         }
-        const amountWithdrawable = freeCollateral
-            .mul(numericConstants_1.MARGIN_PRECISION)
-            .div(new _1.BN(spotMarket.initialAssetWeight))
-            .mul(numericConstants_1.PRICE_PRECISION)
-            .div(oracleData.price)
-            .mul(precisionIncrease);
+        const assetWeight = (0, spotBalance_1.calculateAssetWeight)(userDepositAmount, spotMarket, 'Initial');
+        const amountWithdrawable = assetWeight.eq(numericConstants_1.ZERO)
+            ? userDepositAmount
+            : freeCollateral
+                .mul(numericConstants_1.MARGIN_PRECISION)
+                .div(assetWeight)
+                .mul(numericConstants_1.PRICE_PRECISION)
+                .div(oracleData.price)
+                .mul(precisionIncrease);
         const maxWithdrawValue = _1.BN.min(_1.BN.min(amountWithdrawable, userDepositAmount), withdrawLimit.abs());
         if (reduceOnly) {
             return _1.BN.max(maxWithdrawValue, numericConstants_1.ZERO);
@@ -1702,6 +1760,146 @@ class User {
             spotTier: safestSpotTier,
         };
     }
+    getHealthComponents({ marginCategory, }) {
+        const healthComponents = {
+            deposits: [],
+            borrows: [],
+            perpPositions: [],
+            perpPnl: [],
+        };
+        for (const perpPosition of this.getActivePerpPositions()) {
+            const perpMarket = this.driftClient.getPerpMarketAccount(perpPosition.marketIndex);
+            const oraclePriceData = this.driftClient.getOraclePriceDataAndSlot(perpMarket.amm.oracle).data;
+            const oraclePrice = oraclePriceData.price;
+            const worstCaseBaseAmount = (0, margin_1.calculateWorstCaseBaseAssetAmount)(perpPosition);
+            const marginRatio = new _1.BN((0, _1.calculateMarketMarginRatio)(perpMarket, worstCaseBaseAmount.abs(), marginCategory));
+            const quoteSpotMarket = this.driftClient.getSpotMarketAccount(perpMarket.quoteSpotMarketIndex);
+            const quoteOraclePriceData = this.driftClient.getOraclePriceDataAndSlot(quoteSpotMarket.oracle).data;
+            const baseAssetValue = worstCaseBaseAmount
+                .abs()
+                .mul(oraclePrice)
+                .div(numericConstants_1.BASE_PRECISION);
+            let marginRequirement = baseAssetValue
+                .mul(quoteOraclePriceData.price)
+                .div(numericConstants_1.PRICE_PRECISION)
+                .mul(marginRatio)
+                .div(numericConstants_1.MARGIN_PRECISION);
+            marginRequirement = marginRequirement.add(new _1.BN(perpPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT));
+            if (perpPosition.lpShares.gt(numericConstants_1.ZERO)) {
+                marginRequirement = marginRequirement.add(_1.BN.max(numericConstants_1.QUOTE_PRECISION, oraclePrice
+                    .mul(perpMarket.amm.orderStepSize)
+                    .mul(numericConstants_1.QUOTE_PRECISION)
+                    .div(numericConstants_1.AMM_RESERVE_PRECISION)
+                    .div(numericConstants_1.PRICE_PRECISION)));
+            }
+            healthComponents.perpPositions.push({
+                marketIndex: perpMarket.marketIndex,
+                size: worstCaseBaseAmount,
+                value: baseAssetValue,
+                weight: marginRatio,
+                weightedValue: marginRequirement,
+            });
+            const settledPerpPosition = this.getPerpPositionWithLPSettle(perpPosition.marketIndex, perpPosition)[0];
+            const positionUnrealizedPnl = (0, _1.calculatePositionPNL)(perpMarket, settledPerpPosition, true, oraclePriceData);
+            let pnlWeight;
+            if (positionUnrealizedPnl.gt(numericConstants_1.ZERO)) {
+                pnlWeight = (0, _1.calculateUnrealizedAssetWeight)(perpMarket, quoteSpotMarket, positionUnrealizedPnl, marginCategory, oraclePriceData);
+            }
+            else {
+                pnlWeight = numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION;
+            }
+            const pnlValue = positionUnrealizedPnl
+                .mul(quoteOraclePriceData.price)
+                .div(numericConstants_1.PRICE_PRECISION);
+            const wegithedPnlValue = pnlValue
+                .mul(pnlWeight)
+                .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            healthComponents.perpPnl.push({
+                marketIndex: perpMarket.marketIndex,
+                size: positionUnrealizedPnl,
+                value: pnlValue,
+                weight: pnlWeight,
+                weightedValue: wegithedPnlValue,
+            });
+        }
+        let netQuoteValue = numericConstants_1.ZERO;
+        for (const spotPosition of this.getActiveSpotPositions()) {
+            const spotMarketAccount = this.driftClient.getSpotMarketAccount(spotPosition.marketIndex);
+            const oraclePriceData = this.getOracleDataForSpotMarket(spotPosition.marketIndex);
+            if (spotPosition.marketIndex === numericConstants_1.QUOTE_SPOT_MARKET_INDEX) {
+                const tokenAmount = (0, _1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
+                netQuoteValue = netQuoteValue.add(tokenAmount);
+                continue;
+            }
+            const [worstCaseTokenAmount, worstCaseQuoteTokenAmount] = (0, spotPosition_1.getWorstCaseTokenAmounts)(spotPosition, spotMarketAccount, oraclePriceData);
+            netQuoteValue = netQuoteValue.add(worstCaseQuoteTokenAmount);
+            const baseAssetValue = (0, _1.getTokenValue)(worstCaseTokenAmount.abs(), spotMarketAccount.decimals, oraclePriceData);
+            const isLiability = (0, types_1.isVariant)(spotPosition.balanceType, 'borrow');
+            let weight;
+            if (isLiability) {
+                weight = (0, spotBalance_1.calculateLiabilityWeight)(worstCaseTokenAmount.abs(), spotMarketAccount, marginCategory);
+            }
+            else {
+                weight = (0, spotBalance_1.calculateAssetWeight)(worstCaseTokenAmount, spotMarketAccount, marginCategory);
+            }
+            const weightedValue = baseAssetValue
+                .mul(weight)
+                .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            if (isLiability) {
+                healthComponents.borrows.push({
+                    marketIndex: spotMarketAccount.marketIndex,
+                    size: worstCaseTokenAmount,
+                    value: baseAssetValue,
+                    weight: weight,
+                    weightedValue: weightedValue,
+                });
+            }
+            else {
+                healthComponents.deposits.push({
+                    marketIndex: spotMarketAccount.marketIndex,
+                    size: worstCaseTokenAmount,
+                    value: baseAssetValue,
+                    weight: weight,
+                    weightedValue: weightedValue,
+                });
+            }
+        }
+        if (!netQuoteValue.eq(numericConstants_1.ZERO)) {
+            const spotMarketAccount = this.driftClient.getQuoteSpotMarketAccount();
+            const oraclePriceData = this.getOracleDataForSpotMarket(numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+            const baseAssetValue = (0, _1.getTokenValue)(netQuoteValue.abs(), spotMarketAccount.decimals, oraclePriceData);
+            const isLiability = netQuoteValue.lt(numericConstants_1.ZERO);
+            let weight;
+            if (isLiability) {
+                weight = (0, spotBalance_1.calculateLiabilityWeight)(netQuoteValue.abs(), spotMarketAccount, marginCategory);
+            }
+            else {
+                weight = (0, spotBalance_1.calculateAssetWeight)(netQuoteValue, spotMarketAccount, marginCategory);
+            }
+            const weightedValue = baseAssetValue
+                .mul(weight)
+                .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            if (isLiability) {
+                healthComponents.borrows.push({
+                    marketIndex: spotMarketAccount.marketIndex,
+                    size: netQuoteValue,
+                    value: baseAssetValue,
+                    weight: weight,
+                    weightedValue: weightedValue,
+                });
+            }
+            else {
+                healthComponents.deposits.push({
+                    marketIndex: spotMarketAccount.marketIndex,
+                    size: netQuoteValue,
+                    value: baseAssetValue,
+                    weight: weight,
+                    weightedValue: weightedValue,
+                });
+            }
+        }
+        return healthComponents;
+    }
     /**
      * Get the total position value, excluding any position coming from the given target market
      * @param marketToIgnore

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.37.1-beta.0",
+	"version": "2.37.1-beta.10",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -55,7 +55,7 @@
 		"eslint-plugin-prettier": "^3.4.0",
 		"lodash": "^4.17.21",
 		"mocha": "^10.0.0",
-		"prettier": "^2.4.1",
+		"prettier": "^3.0.1",
 		"ts-node": "^10.8.0",
 		"typescript": "^4.9.5"
 	},

package/src/adminClient.ts

@@ -691,6 +691,24 @@ export class AdminClient extends DriftClient {
 		});
 	}
 
+	public async updatePerpMarketPerLpBase(
+		perpMarketIndex: number,
+		perLpBase: number
+	): Promise<TransactionSignature> {
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
+			this.program.programId,
+			perpMarketIndex
+		);
+
+		return await this.program.rpc.updatePerpMarketPerLpBase(perLpBase, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				perpMarket: perpMarketPublicKey,
+			},
+		});
+	}
+
 	public async updatePerpMarketMaxSpread(
 		perpMarketIndex: number,
 		maxSpread: number

package/src/constants/perpMarkets.ts

@@ -154,6 +154,16 @@ export const DevnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1689270550000,
 		oracleSource: OracleSource.PYTH,
 	},
+	{
+		fullName: 'HNT',
+		category: ['IoT'],
+		symbol: 'HNT-PERP',
+		baseAssetSymbol: 'HNT',
+		marketIndex: 14,
+		oracle: new PublicKey('6Eg8YdfFJQF2HHonzPUBSCCmyUEhrStg9VBLK957sBe6'),
+		launchTs: 16922949550000,
+		oracleSource: OracleSource.PYTH,
+	},
 ];
 
 export const MainnetPerpMarkets: PerpMarketConfig[] = [
@@ -297,6 +307,16 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1689270550000,
 		oracleSource: OracleSource.PYTH,
 	},
+	{
+		fullName: 'HNT',
+		category: ['IoT'],
+		symbol: 'HNT-PERP',
+		baseAssetSymbol: 'HNT',
+		marketIndex: 14,
+		oracle: new PublicKey('7moA1i5vQUpfDwSpK6Pw9s56ahB7WFGidtbL2ujWrVvm'),
+		launchTs: 16922949550000,
+		oracleSource: OracleSource.PYTH,
+	},
 ];
 
 export const PerpMarkets: { [key in DriftEnv]: PerpMarketConfig[] } = {

package/src/events/eventSubscriber.ts

@@ -168,6 +168,7 @@ export class EventSubscriber {
 		const records = [];
 		// @ts-ignore
 		const events = parseLogs(this.program, slot, logs);
+		let runningEventIndex = 0;
 		for (const event of events) {
 			// @ts-ignore
 			const expectRecordType = this.eventListMap.has(event.name);
@@ -175,8 +176,10 @@ export class EventSubscriber {
 				event.data.txSig = txSig;
 				event.data.slot = slot;
 				event.data.eventType = event.name;
+				event.data.txSigIndex = runningEventIndex;
 				records.push(event.data);
 			}
+			runningEventIndex++;
 		}
 		return records;
 	}

package/src/events/fetchLogs.ts

@@ -155,11 +155,14 @@ export class LogParser {
 			event.logs,
 			false
 		);
+		let runningEventIndex = 0;
 		for (const eventLog of eventGenerator) {
 			eventLog.data.txSig = event.txSig;
 			eventLog.data.slot = event.slot;
 			eventLog.data.eventType = eventLog.name;
+			eventLog.data.txSigIndex = runningEventIndex;
 			records.push(eventLog.data);
+			runningEventIndex++;
 		}
 		return records;
 	}

package/src/events/types.ts

@@ -64,6 +64,7 @@ export type EventSubscriptionOrderDirection = 'asc' | 'desc';
 export type Event<T> = T & {
 	txSig: TransactionSignature;
 	slot: number;
+	txSigIndex: number; // Unique index for each event inside a tx
 };
 
 export type WrappedEvent<Type extends EventType> = EventMap[Type] & {

package/src/idl/drift.json

@@ -1122,6 +1122,31 @@
         }
       ]
     },
+    {
+      "name": "updateUserReduceOnly",
+      "accounts": [
+        {
+          "name": "user",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        }
+      ],
+      "args": [
+        {
+          "name": "subAccountId",
+          "type": "u16"
+        },
+        {
+          "name": "reduceOnly",
+          "type": "bool"
+        }
+      ]
+    },
     {
       "name": "deleteUser",
       "accounts": [
@@ -3857,6 +3882,32 @@
         }
       ]
     },
+    {
+      "name": "updatePerpMarketPerLpBase",
+      "accounts": [
+        {
+          "name": "admin",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "perpMarket",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "perLpBase",
+          "type": "i8"
+        }
+      ]
+    },
     {
       "name": "updateLpCooldownTime",
       "accounts": [
@@ -6953,9 +7004,20 @@
             ],
             "type": "i32"
           },
+          {
+            "name": "perLpBase",
+            "docs": [
+              "expo for unit of per_lp, base 10 (if per_lp_base=X, then per_lp unit is 10^X)"
+            ],
+            "type": "i8"
+          },
           {
             "name": "padding1",
-            "type": "u32"
+            "type": "u8"
+          },
+          {
+            "name": "padding2",
+            "type": "u16"
           },
           {
             "name": "totalFeeEarnedPerLp",
@@ -7422,13 +7484,8 @@
             "type": "u8"
           },
           {
-            "name": "padding",
-            "type": {
-              "array": [
-                "u8",
-                1
-              ]
-            }
+            "name": "perLpBase",
+            "type": "i8"
           }
         ]
       }
@@ -8314,6 +8371,9 @@
           },
           {
             "name": "Bankrupt"
+          },
+          {
+            "name": "ReduceOnly"
           }
         ]
       }
@@ -10681,6 +10741,11 @@
       "code": 6253,
       "name": "CantUpdatePerpBidAskTwap",
       "msg": "CantUpdatePerpBidAskTwap"
+    },
+    {
+      "code": 6254,
+      "name": "UserReduceOnly",
+      "msg": "UserReduceOnly"
     }
   ]
 }

package/src/index.ts

@@ -61,6 +61,7 @@ export * from './serum/serumSubscriber';
 export * from './serum/serumFulfillmentConfigMap';
 export * from './phoenix/phoenixSubscriber';
 export * from './phoenix/phoenixFulfillmentConfigMap';
+export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';
 export * from './tx/types';
 export * from './util/computeUnits';