@drift-labs/sdk 2.13.0-beta.2 → 2.14.0-beta.0

package/src/math/funding.ts

@@ -19,7 +19,8 @@ import { calculateBidAskPrice } from './amm';
 export async function calculateAllEstimatedFundingRate(
 	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
-	periodAdjustment: BN = new BN(1)
+	periodAdjustment: BN = new BN(1),
+	now?: BN
 ): Promise<[BN, BN, BN, BN, BN]> {
 	// periodAdjustment
 	// 	1: hourly
@@ -36,7 +37,7 @@ export async function calculateAllEstimatedFundingRate(
 	const payFreq = new BN(market.amm.fundingPeriod);
 
 	// todo: sufficiently differs from blockchain timestamp?
-	const now = new BN((Date.now() / 1000).toFixed(0));
+	now = now || new BN((Date.now() / 1000).toFixed(0));
 	const timeSinceLastUpdate = now.sub(market.amm.lastFundingRateTs);
 
 	// calculate real-time mark twap
@@ -89,8 +90,8 @@ export async function calculateAllEstimatedFundingRate(
 			.mul(new BN(100))
 			.div(lastOracleTwapWithMantissa);
 
-		// verify pyth live input is within 10% of last twap for live update
-		if (oracleLiveVsTwap.lte(PRICE_PRECISION.mul(new BN(10)))) {
+		// verify pyth live input is within 20% of last twap for live update
+		if (oracleLiveVsTwap.lte(PRICE_PRECISION.mul(new BN(20)))) {
 			oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
 				.mul(lastOracleTwapWithMantissa)
 				.add(timeSinceLastMarkChange.mul(oraclePrice))
@@ -99,13 +100,11 @@ export async function calculateAllEstimatedFundingRate(
 	}
 
 	const shrunkLastOracleTwapwithMantissa = oracleTwapTimeSinceLastUpdate
-		.mul(lastOracleTwapWithMantissa)
+		.mul(oracleTwapWithMantissa)
 		.add(oracleInvalidDuration.mul(lastMarkTwapWithMantissa))
 		.div(oracleTwapTimeSinceLastUpdate.add(oracleInvalidDuration));
 
-	const twapSpread = lastMarkTwapWithMantissa.sub(
-		shrunkLastOracleTwapwithMantissa
-	);
+	const twapSpread = markTwapWithMantissa.sub(shrunkLastOracleTwapwithMantissa);
 
 	const twapSpreadPct = twapSpread
 		.mul(PRICE_PRECISION)

package/src/math/spotBalance.ts

@@ -131,7 +131,11 @@ export function calculateAssetWeight(
 			);
 			break;
 		case 'Maintenance':
-			assetWeight = new BN(spotMarket.maintenanceAssetWeight);
+			assetWeight = calculateSizeDiscountAssetWeight(
+				sizeInAmmReservePrecision,
+				new BN(spotMarket.imfFactor),
+				new BN(spotMarket.maintenanceAssetWeight)
+			);
 			break;
 		default:
 			assetWeight = new BN(spotMarket.initialAssetWeight);
@@ -322,12 +326,15 @@ export function calculateWithdrawLimit(
 		.add(marketDepositTokenAmount.mul(sinceLast))
 		.div(sinceLast.add(sinceStart));
 
-	const maxBorrowTokens = BN.min(
-		BN.max(
-			marketDepositTokenAmount.div(new BN(6)),
-			borrowTokenTwapLive.add(borrowTokenTwapLive.div(new BN(5)))
-		),
-		marketDepositTokenAmount.sub(marketDepositTokenAmount.div(new BN(5)))
+	const maxBorrowTokens = BN.max(
+		spotMarket.withdrawGuardThreshold,
+		BN.min(
+			BN.max(
+				marketDepositTokenAmount.div(new BN(6)),
+				borrowTokenTwapLive.add(borrowTokenTwapLive.div(new BN(5)))
+			),
+			marketDepositTokenAmount.sub(marketDepositTokenAmount.div(new BN(5)))
+		)
 	); // between ~15-80% utilization with friction on twap
 
 	const minDepositTokens = depositTokenTwapLive.sub(

package/src/token/index.ts

@@ -10,7 +10,7 @@ export function parseTokenAccount(data: Buffer): AccountInfo {
 	if (accountInfo.delegateOption === 0) {
 		accountInfo.delegate = null;
 		// eslint-disable-next-line new-cap
-		accountInfo.delegatedAmount = new u64(0);
+		accountInfo.delegatedAmount = u64.fromBuffer(Buffer.from('0'));
 	} else {
 		accountInfo.delegate = new PublicKey(accountInfo.delegate);
 		accountInfo.delegatedAmount = u64.fromBuffer(accountInfo.delegatedAmount);

package/src/user.ts

@@ -10,6 +10,7 @@ import {
 	PerpPosition,
 	SpotPosition,
 	isOneOfVariant,
+	PerpMarketAccount,
 } from './types';
 import { calculateEntryPrice } from './math/position';
 import {
@@ -20,13 +21,13 @@ import {
 	BN_MAX,
 	QUOTE_PRECISION,
 	AMM_RESERVE_PRECISION,
-	PRICE_TO_QUOTE_PRECISION,
 	MARGIN_PRECISION,
 	SPOT_MARKET_WEIGHT_PRECISION,
 	QUOTE_SPOT_MARKET_INDEX,
 	TEN,
 	OPEN_ORDER_MARGIN_REQUIREMENT,
 	FIVE_MINUTE,
+	BASE_PRECISION,
 } from './constants/numericConstants';
 import {
 	UserAccountSubscriber,
@@ -45,6 +46,7 @@ import {
 	SpotMarketAccount,
 	getTokenValue,
 	getStrictTokenValue,
+	getSignedTokenAmount,
 } from '.';
 import {
 	getTokenAmount,
@@ -1279,238 +1281,244 @@ export class User {
 	}
 
 	/**
-	 * Calculate the liquidation price of a perp position, with optional parameter to calculate the liquidation price after a trade
-	 * @param PerpPosition
-	 * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
-	 * @param partial
+	 * Calculate the liquidation price of a spot position
+	 * @param marketIndex
 	 * @returns Precision : PRICE_PRECISION
 	 */
-	public spotLiquidationPrice(
-		spotPosition: Pick<SpotPosition, 'marketIndex'>
-	): BN {
-		const currentSpotPosition = this.getSpotPosition(spotPosition.marketIndex);
+	public spotLiquidationPrice(marketIndex: number): BN {
+		const currentSpotPosition = this.getSpotPosition(marketIndex);
 
 		if (!currentSpotPosition) {
 			return new BN(-1);
 		}
 
-		const mtc = this.getTotalCollateral('Maintenance');
-		const mmr = this.getMaintenanceMarginRequirement();
-
-		const deltaValueToLiq = mtc.sub(mmr); // QUOTE_PRECISION
-
-		const currentSpotMarket = this.driftClient.getSpotMarketAccount(
-			spotPosition.marketIndex
+		const totalCollateral = this.getTotalCollateral('Maintenance');
+		const maintenanceMarginRequirement = this.getMaintenanceMarginRequirement();
+		const freeCollateral = BN.max(
+			ZERO,
+			totalCollateral.sub(maintenanceMarginRequirement)
 		);
-		const tokenAmount = getTokenAmount(
-			currentSpotPosition.scaledBalance,
-			currentSpotMarket,
+
+		const market = this.driftClient.getSpotMarketAccount(marketIndex);
+		const signedTokenAmount = getSignedTokenAmount(
+			getTokenAmount(
+				currentSpotPosition.scaledBalance,
+				market,
+				currentSpotPosition.balanceType
+			),
 			currentSpotPosition.balanceType
 		);
-		const tokenAmountQP = tokenAmount
-			.mul(QUOTE_PRECISION)
-			.div(new BN(10 ** currentSpotMarket.decimals));
 
-		if (tokenAmountQP.abs().eq(ZERO)) {
+		if (signedTokenAmount.eq(ZERO)) {
 			return new BN(-1);
 		}
-		let liqPriceDelta: BN;
-		if (isVariant(currentSpotPosition.balanceType, 'borrow')) {
-			liqPriceDelta = deltaValueToLiq
-				.mul(PRICE_PRECISION)
-				.mul(SPOT_MARKET_WEIGHT_PRECISION)
-				.div(tokenAmountQP)
-				.div(new BN(currentSpotMarket.maintenanceLiabilityWeight));
-		} else {
-			liqPriceDelta = deltaValueToLiq
-				.mul(PRICE_PRECISION)
-				.mul(SPOT_MARKET_WEIGHT_PRECISION)
-				.div(tokenAmountQP)
-				.div(new BN(currentSpotMarket.maintenanceAssetWeight))
-				.mul(new BN(-1));
+
+		let freeCollateralDelta = this.calculateFreeCollateralDeltaForSpot(
+			market,
+			signedTokenAmount
+		);
+
+		const oracle = market.oracle;
+		const perpMarketWithSameOracle = this.driftClient
+			.getPerpMarketAccounts()
+			.find((market) => market.amm.oracle.equals(oracle));
+		if (perpMarketWithSameOracle) {
+			const perpPosition = this.getPerpPosition(
+				perpMarketWithSameOracle.marketIndex
+			);
+			if (perpPosition) {
+				const freeCollateralDeltaForPerp =
+					this.calculateFreeCollateralDeltaForPerp(
+						perpMarketWithSameOracle,
+						perpPosition,
+						ZERO
+					);
+
+				freeCollateralDelta = freeCollateralDelta.add(
+					freeCollateralDeltaForPerp || ZERO
+				);
+			}
 		}
 
-		const currentPrice = this.driftClient.getOracleDataForSpotMarket(
-			spotPosition.marketIndex
-		).price;
+		if (freeCollateralDelta.eq(ZERO)) {
+			return new BN(-1);
+		}
+
+		const oraclePrice =
+			this.driftClient.getOracleDataForSpotMarket(marketIndex).price;
+		const liqPriceDelta = freeCollateral
+			.mul(QUOTE_PRECISION)
+			.div(freeCollateralDelta);
 
-		const liqPrice = currentPrice.add(liqPriceDelta);
+		const liqPrice = oraclePrice.sub(liqPriceDelta);
+
+		if (liqPrice.lt(ZERO)) {
+			return new BN(-1);
+		}
 
 		return liqPrice;
 	}
 
 	/**
 	 * Calculate the liquidation price of a perp position, with optional parameter to calculate the liquidation price after a trade
-	 * @param PerpPosition
+	 * @param marketIndex
 	 * @param positionBaseSizeChange // change in position size to calculate liquidation price for : Precision 10^13
-	 * @param partial
 	 * @returns Precision : PRICE_PRECISION
 	 */
 	public liquidationPrice(
-		perpPosition: Pick<PerpPosition, 'marketIndex'>,
+		marketIndex: number,
 		positionBaseSizeChange: BN = ZERO
 	): BN {
-		// solves formula for example canBeLiquidated below
-
-		/* example: assume BTC price is $40k (examine 10% up/down)
+		const totalCollateral = this.getTotalCollateral('Maintenance');
+		const maintenanceMarginRequirement = this.getMaintenanceMarginRequirement();
+		const freeCollateral = BN.max(
+			ZERO,
+			totalCollateral.sub(maintenanceMarginRequirement)
+		);
 
-        if 10k deposit and levered 10x short BTC => BTC up $400 means:
-        1. higher base_asset_value (+$4k)
-        2. lower collateral (-$4k)
-        3. (10k - 4k)/(100k + 4k) => 6k/104k => .0576
+		const market = this.driftClient.getPerpMarketAccount(marketIndex);
+		const currentPerpPosition = this.getPerpPosition(marketIndex);
 
-        for 10x long, BTC down $400:
-        3. (10k - 4k) / (100k - 4k) = 6k/96k => .0625 */
+		let freeCollateralDelta = this.calculateFreeCollateralDeltaForPerp(
+			market,
+			currentPerpPosition,
+			positionBaseSizeChange
+		);
 
-		const totalCollateral = this.getTotalCollateral('Maintenance');
+		if (!freeCollateralDelta) {
+			return new BN(-1);
+		}
 
-		// calculate the total position value ignoring any value from the target market of the trade
-		const totalPositionValueExcludingTargetMarket =
-			this.getTotalPerpPositionValueExcludingMarket(
-				perpPosition.marketIndex,
-				undefined,
-				undefined,
-				true
+		const oracle =
+			this.driftClient.getPerpMarketAccount(marketIndex).amm.oracle;
+		const spotMarketWithSameOracle = this.driftClient
+			.getSpotMarketAccounts()
+			.find((market) => market.oracle.equals(oracle));
+		if (spotMarketWithSameOracle) {
+			const spotPosition = this.getSpotPosition(
+				spotMarketWithSameOracle.marketIndex
 			);
+			if (spotPosition) {
+				const signedTokenAmount = getSignedTokenAmount(
+					getTokenAmount(
+						spotPosition.scaledBalance,
+						spotMarketWithSameOracle,
+						spotPosition.balanceType
+					),
+					spotPosition.balanceType
+				);
 
-		const currentPerpPosition =
-			this.getPerpPosition(perpPosition.marketIndex) ||
-			this.getEmptyPosition(perpPosition.marketIndex);
+				const spotFreeCollateralDelta =
+					this.calculateFreeCollateralDeltaForSpot(
+						spotMarketWithSameOracle,
+						signedTokenAmount
+					);
+				freeCollateralDelta = freeCollateralDelta.add(
+					spotFreeCollateralDelta || ZERO
+				);
+			}
+		}
 
-		const currentPerpPositionBaseSize = currentPerpPosition.baseAssetAmount;
+		if (freeCollateralDelta.eq(ZERO)) {
+			return new BN(-1);
+		}
 
-		const proposedBaseAssetAmount = currentPerpPositionBaseSize.add(
-			positionBaseSizeChange
-		);
+		const oraclePrice =
+			this.driftClient.getOracleDataForPerpMarket(marketIndex).price;
+		const liqPriceDelta = freeCollateral
+			.mul(QUOTE_PRECISION)
+			.div(freeCollateralDelta);
 
-		// calculate position for current market after trade
-		const proposedPerpPosition: PerpPosition = {
-			marketIndex: perpPosition.marketIndex,
-			baseAssetAmount: proposedBaseAssetAmount,
-			remainderBaseAssetAmount: 0,
-			quoteAssetAmount: currentPerpPosition.quoteAssetAmount,
-			lastCumulativeFundingRate: ZERO,
-			quoteBreakEvenAmount: new BN(0),
-			quoteEntryAmount: new BN(0),
-			openOrders: 0,
-			openBids: currentPerpPosition.openBids,
-			openAsks: currentPerpPosition.openAsks,
-			settledPnl: ZERO,
-			lpShares: ZERO,
-			lastBaseAssetAmountPerLp: ZERO,
-			lastQuoteAssetAmountPerLp: ZERO,
-		};
+		const liqPrice = oraclePrice.sub(liqPriceDelta);
 
-		if (proposedBaseAssetAmount.eq(ZERO)) return new BN(-1);
+		if (liqPrice.lt(ZERO)) {
+			return new BN(-1);
+		}
 
-		const market = this.driftClient.getPerpMarketAccount(
-			proposedPerpPosition.marketIndex
-		);
+		return liqPrice;
+	}
 
-		const proposedPerpPositionValue = calculateBaseAssetValueWithOracle(
-			market,
-			proposedPerpPosition,
-			this.getOracleDataForPerpMarket(market.marketIndex),
-			true
+	calculateFreeCollateralDeltaForPerp(
+		market: PerpMarketAccount,
+		perpPosition: PerpPosition,
+		positionBaseSizeChange: BN
+	): BN | undefined {
+		const currentBaseAssetAmount = perpPosition.baseAssetAmount;
+
+		const worstCaseBaseAssetAmount =
+			calculateWorstCaseBaseAssetAmount(perpPosition);
+		const orderBaseAssetAmount = worstCaseBaseAssetAmount.sub(
+			currentBaseAssetAmount
+		);
+		const proposedBaseAssetAmount = currentBaseAssetAmount.add(
+			positionBaseSizeChange
+		);
+		const proposedWorstCaseBaseAssetAmount = worstCaseBaseAssetAmount.add(
+			positionBaseSizeChange
 		);
 
-		// total position value after trade
-		const totalPositionValueAfterTrade =
-			totalPositionValueExcludingTargetMarket.add(proposedPerpPositionValue);
-
-		const marginRequirementOfAll = this.getMaintenanceMarginRequirement();
-		const positionValue = calculateBaseAssetValueWithOracle(
+		const marginRatio = calculateMarketMarginRatio(
 			market,
-			currentPerpPosition,
-			this.getOracleDataForPerpMarket(market.marketIndex),
-			true
+			proposedWorstCaseBaseAssetAmount.abs(),
+			'Maintenance'
 		);
-		const marginRequirementOfTargetMarket = positionValue
-			.mul(
-				new BN(
-					calculateMarketMarginRatio(
-						market,
-						calculateWorstCaseBaseAssetAmount(currentPerpPosition).abs(),
-						'Maintenance'
-					)
-				)
-			)
+		const marginRatioQuotePrecision = new BN(marginRatio)
+			.mul(QUOTE_PRECISION)
 			.div(MARGIN_PRECISION);
 
-		const marginRequirementExcludingTargetMarket = marginRequirementOfAll.sub(
-			marginRequirementOfTargetMarket
-		);
+		if (proposedWorstCaseBaseAssetAmount.eq(ZERO)) {
+			return undefined;
+		}
 
-		const freeCollateralExcludingTargetMarket = totalCollateral.sub(
-			marginRequirementExcludingTargetMarket
-		);
+		let freeCollateralDelta = ZERO;
+		if (proposedBaseAssetAmount.gt(ZERO)) {
+			freeCollateralDelta = QUOTE_PRECISION.sub(marginRatioQuotePrecision)
+				.mul(proposedBaseAssetAmount)
+				.div(BASE_PRECISION);
+		} else {
+			freeCollateralDelta = QUOTE_PRECISION.neg()
+				.sub(marginRatioQuotePrecision)
+				.mul(proposedBaseAssetAmount.abs())
+				.div(BASE_PRECISION);
+		}
 
-		// if the position value after the trade is less than free collateral, there is no liq price
-		if (
-			totalPositionValueAfterTrade.lte(freeCollateralExcludingTargetMarket) &&
-			proposedPerpPosition.baseAssetAmount.gt(ZERO)
-		) {
-			return new BN(-1);
+		if (!orderBaseAssetAmount.eq(ZERO)) {
+			freeCollateralDelta = freeCollateralDelta.sub(marginRatioQuotePrecision);
 		}
 
-		const proposedWorstCastBaseAssetAmount =
-			calculateWorstCaseBaseAssetAmount(proposedPerpPosition);
-		const marginRequirementTargetMarket = proposedPerpPositionValue
-			.mul(
-				new BN(
-					calculateMarketMarginRatio(
-						market,
-						proposedWorstCastBaseAssetAmount.abs(),
-						'Maintenance'
-					)
-				)
-			)
-			.div(MARGIN_PRECISION);
+		return freeCollateralDelta;
+	}
 
-		const marginRequirementAfterTrade =
-			marginRequirementExcludingTargetMarket.add(marginRequirementTargetMarket);
-		const freeCollateralAfterTrade = totalCollateral.sub(
-			marginRequirementAfterTrade
-		);
+	calculateFreeCollateralDeltaForSpot(
+		market: SpotMarketAccount,
+		signedTokenAmount: BN
+	): BN {
+		const tokenPrecision = new BN(Math.pow(10, market.decimals));
 
-		const marketMaxMaintLeverage = new BN(
-			TEN_THOUSAND.mul(TEN_THOUSAND).toNumber() /
-				calculateMarketMarginRatio(
-					market,
-					proposedWorstCastBaseAssetAmount.abs(),
-					'Maintenance'
-				)
-		);
+		if (signedTokenAmount.gt(ZERO)) {
+			const assetWeight = calculateAssetWeight(
+				signedTokenAmount,
+				market,
+				'Maintenance'
+			);
 
-		let priceDelta;
-		if (proposedBaseAssetAmount.lt(ZERO)) {
-			priceDelta = freeCollateralAfterTrade
-				.mul(marketMaxMaintLeverage) // precision is TEN_THOUSAND
-				.div(marketMaxMaintLeverage.add(TEN_THOUSAND))
-				.mul(PRICE_TO_QUOTE_PRECISION)
-				.mul(AMM_RESERVE_PRECISION)
-				.div(proposedBaseAssetAmount);
+			return QUOTE_PRECISION.mul(assetWeight)
+				.div(SPOT_MARKET_WEIGHT_PRECISION)
+				.mul(signedTokenAmount)
+				.div(tokenPrecision);
 		} else {
-			priceDelta = freeCollateralAfterTrade
-				.mul(marketMaxMaintLeverage) // precision is TEN_THOUSAND
-				.div(marketMaxMaintLeverage.sub(TEN_THOUSAND))
-				.mul(PRICE_TO_QUOTE_PRECISION)
-				.mul(AMM_RESERVE_PRECISION)
-				.div(proposedBaseAssetAmount);
-		}
-
-		const currentPrice = this.getOracleDataForPerpMarket(
-			perpPosition.marketIndex
-		).price;
+			const liabilityWeight = calculateLiabilityWeight(
+				signedTokenAmount.abs(),
+				market,
+				'Maintenance'
+			);
 
-		if (
-			priceDelta.gt(currentPrice) &&
-			proposedPerpPosition.baseAssetAmount.gte(ZERO)
-		) {
-			return new BN(-1);
+			return QUOTE_PRECISION.neg()
+				.mul(liabilityWeight)
+				.div(SPOT_MARKET_WEIGHT_PRECISION)
+				.mul(signedTokenAmount.abs())
+				.div(tokenPrecision);
 		}
-
-		return currentPrice.sub(priceDelta);
 	}
 
 	/**
@@ -1537,12 +1545,7 @@ export class User {
 			)
 			.neg();
 
-		return this.liquidationPrice(
-			{
-				marketIndex: positionMarketIndex,
-			},
-			closeBaseAmount
-		);
+		return this.liquidationPrice(positionMarketIndex, closeBaseAmount);
 	}
 
 	/**
@@ -1845,7 +1848,7 @@ export class User {
 			return {
 				canBypass: false,
 				maxDepositAmount,
-				depositAmount: ZERO,
+				depositAmount,
 				netDeposits,
 			};
 		}

package/src/assert/assert.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assert = void 0;
-function assert(condition, error) {
-    if (!condition) {
-        throw new Error(error || 'Unspecified AssertionError');
-    }
-}
-exports.assert = assert;

package/src/token/index.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTokenAccount = void 0;
-const spl_token_1 = require("@solana/spl-token");
-const web3_js_1 = require("@solana/web3.js");
-function parseTokenAccount(data) {
-    const accountInfo = spl_token_1.AccountLayout.decode(data);
-    accountInfo.mint = new web3_js_1.PublicKey(accountInfo.mint);
-    accountInfo.owner = new web3_js_1.PublicKey(accountInfo.owner);
-    accountInfo.amount = spl_token_1.u64.fromBuffer(accountInfo.amount);
-    if (accountInfo.delegateOption === 0) {
-        accountInfo.delegate = null;
-        // eslint-disable-next-line new-cap
-        accountInfo.delegatedAmount = new spl_token_1.u64(0);
-    }
-    else {
-        accountInfo.delegate = new web3_js_1.PublicKey(accountInfo.delegate);
-        accountInfo.delegatedAmount = spl_token_1.u64.fromBuffer(accountInfo.delegatedAmount);
-    }
-    accountInfo.isInitialized = accountInfo.state !== 0;
-    accountInfo.isFrozen = accountInfo.state === 2;
-    if (accountInfo.isNativeOption === 1) {
-        accountInfo.rentExemptReserve = spl_token_1.u64.fromBuffer(accountInfo.isNative);
-        accountInfo.isNative = true;
-    }
-    else {
-        accountInfo.rentExemptReserve = null;
-        accountInfo.isNative = false;
-    }
-    if (accountInfo.closeAuthorityOption === 0) {
-        accountInfo.closeAuthority = null;
-    }
-    else {
-        accountInfo.closeAuthority = new web3_js_1.PublicKey(accountInfo.closeAuthority);
-    }
-    return accountInfo;
-}
-exports.parseTokenAccount = parseTokenAccount;

package/src/tx/types.js

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

package/src/tx/utils.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapInTx = void 0;
-const web3_js_1 = require("@solana/web3.js");
-const COMPUTE_UNITS_DEFAULT = 200000;
-function wrapInTx(instruction, computeUnits = 600000 // TODO, requires less code change
-) {
-    const tx = new web3_js_1.Transaction();
-    if (computeUnits != COMPUTE_UNITS_DEFAULT) {
-        tx.add(web3_js_1.ComputeBudgetProgram.requestUnits({
-            units: computeUnits,
-            additionalFee: 0,
-        }));
-    }
-    return tx.add(instruction);
-}
-exports.wrapInTx = wrapInTx;

package/src/util/computeUnits.js

@@ -1,27 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findComputeUnitConsumption = void 0;
-function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
-    return __awaiter(this, void 0, void 0, function* () {
-        const tx = yield connection.getTransaction(txSignature, { commitment });
-        const computeUnits = [];
-        const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of ([0-9]{0,7}) compute units`);
-        tx.meta.logMessages.forEach((logMessage) => {
-            const match = logMessage.match(regex);
-            if (match && match[1]) {
-                computeUnits.push(match[1]);
-            }
-        });
-        return computeUnits;
-    });
-}
-exports.findComputeUnitConsumption = findComputeUnitConsumption;

package/src/util/getTokenAddress.js

@@ -1,9 +0,0 @@
-"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;