@drift-labs/sdk 2.28.0-beta.3 → 2.28.0-beta.5

package/src/math/spotMarket.ts

@@ -9,10 +9,14 @@ import { calculateAssetWeight, calculateLiabilityWeight } from './spotBalance';
 import { MARGIN_PRECISION } from '../constants/numericConstants';
 
 export function castNumberToSpotPrecision(
-	value: number,
+	value: number | BN,
 	spotMarket: SpotMarketAccount
 ): BN {
-	return new BN(value * Math.pow(10, spotMarket.decimals));
+	if (typeof value === 'number') {
+		return new BN(value * Math.pow(10, spotMarket.decimals));
+	} else {
+		return value.mul(new BN(Math.pow(10, spotMarket.decimals)));
+	}
 }
 
 export function calculateSpotMarketMarginRatio(

package/src/math/utils.ts

@@ -33,3 +33,49 @@ export const divCeil = (a: BN, b: BN): BN => {
 		return quotient;
 	}
 };
+
+/**
+ * calculates the time remaining until the next update based on a rounded, "on-the-hour" update schedule
+ * this schedule is used for Perpetual Funding Rate and Revenue -> Insurance Updates
+ * @param now: current blockchain unix timestamp
+ * @param lastUpdateTs: the unix timestamp of the last update
+ * @param updatePeriod: desired interval between updates (in seconds)
+ * @returns: timeRemainingUntilUpdate (in seconds)
+ */
+export function timeRemainingUntilUpdate(
+	now: BN,
+	lastUpdateTs: BN,
+	updatePeriod: BN
+): BN {
+	const timeSinceLastUpdate = now.sub(lastUpdateTs);
+
+	// round next update time to be available on the hour
+	let nextUpdateWait = updatePeriod;
+	if (updatePeriod.gt(new BN(1))) {
+		const lastUpdateDelay = lastUpdateTs.umod(updatePeriod);
+		if (!lastUpdateDelay.isZero()) {
+			const maxDelayForNextPeriod = updatePeriod.div(new BN(3));
+
+			const twoFundingPeriods = updatePeriod.mul(new BN(2));
+
+			if (lastUpdateDelay.gt(maxDelayForNextPeriod)) {
+				// too late for on the hour next period, delay to following period
+				nextUpdateWait = twoFundingPeriods.sub(lastUpdateDelay);
+			} else {
+				// allow update on the hour
+				nextUpdateWait = updatePeriod.sub(lastUpdateDelay);
+			}
+
+			if (nextUpdateWait.gt(twoFundingPeriods)) {
+				nextUpdateWait = nextUpdateWait.sub(updatePeriod);
+			}
+		}
+	}
+	const timeRemainingUntilUpdate = nextUpdateWait
+		.sub(timeSinceLastUpdate)
+		.isNeg()
+		? ZERO
+		: nextUpdateWait.sub(timeSinceLastUpdate);
+
+	return timeRemainingUntilUpdate;
+}

package/src/phoenix/phoenixSubscriber.ts

@@ -163,8 +163,10 @@ export class PhoenixSubscriber implements L2OrderBookGenerator {
 	}
 
 	*getL2Levels(side: 'bids' | 'asks'): Generator<L2Level> {
-		// @ts-ignore
-		const basePrecision = Math.pow(10, this.market.header.baseParams.decimals);
+		const basePrecision = Math.pow(
+			10,
+			this.market.data.header.baseParams.decimals
+		);
 		const pricePrecision = PRICE_PRECISION.toNumber();
 
 		const ladder = getMarketUiLadder(

package/src/tx/retryTxSender.ts

@@ -115,18 +115,10 @@ export class RetryTxSender implements TxSender {
 	}
 
 	async sendVersionedTransaction(
-		ixs: TransactionInstruction[],
-		lookupTableAccounts: AddressLookupTableAccount[],
+		tx: VersionedTransaction,
 		additionalSigners?: Array<Signer>,
 		opts?: ConfirmOptions
 	): Promise<TxSigAndSlot> {
-		const tx = await this.getVersionedTransaction(
-			ixs,
-			lookupTableAccounts,
-			additionalSigners,
-			opts
-		);
-
 		// @ts-ignore
 		tx.sign(additionalSigners.concat(this.provider.wallet.payer));
 

package/src/tx/types.ts

@@ -25,8 +25,7 @@ export interface TxSender {
 	): Promise<TxSigAndSlot>;
 
 	sendVersionedTransaction(
-		ixs: TransactionInstruction[],
-		lookupTableAccounts: AddressLookupTableAccount[],
+		tx: VersionedTransaction,
 		additionalSigners?: Array<Signer>,
 		opts?: ConfirmOptions
 	): Promise<TxSigAndSlot>;

package/src/types.ts

@@ -857,7 +857,6 @@ export type OrderParams = {
 	immediateOrCancel: boolean;
 	triggerPrice: BN | null;
 	triggerCondition: OrderTriggerCondition;
-	positionLimit: BN;
 	oraclePriceOffset: number | null;
 	auctionDuration: number | null;
 	maxTs: BN | null;
@@ -899,7 +898,6 @@ export const DefaultOrderParams: OrderParams = {
 	immediateOrCancel: false,
 	triggerPrice: null,
 	triggerCondition: OrderTriggerCondition.ABOVE,
-	positionLimit: ZERO,
 	oraclePriceOffset: null,
 	auctionDuration: null,
 	maxTs: null,

package/src/user.ts

@@ -162,6 +162,28 @@ export class User {
 		);
 	}
 
+	/**
+	 * Returns the token amount for a given market. The spot market precision is based on the token mint decimals.
+	 * Positive if it is a deposit, negative if it is a borrow.
+	 *
+	 * @param marketIndex
+	 */
+	public getTokenAmount(marketIndex: number): BN {
+		const spotPosition = this.getSpotPosition(marketIndex);
+		if (spotPosition === undefined) {
+			return ZERO;
+		}
+		const spotMarket = this.driftClient.getSpotMarketAccount(marketIndex);
+		return getSignedTokenAmount(
+			getTokenAmount(
+				spotPosition.scaledBalance,
+				spotMarket,
+				spotPosition.balanceType
+			),
+			spotPosition.balanceType
+		);
+	}
+
 	public getEmptyPosition(marketIndex: number): PerpPosition {
 		return {
 			baseAssetAmount: ZERO,
@@ -206,6 +228,12 @@ export class User {
 		);
 	}
 
+	public getOpenOrders(): Order[] {
+		return this.getUserAccount()?.orders.filter((order) =>
+			isVariant(order.status, 'open')
+		);
+	}
+
 	public getUserAccountPublicKey(): PublicKey {
 		return this.userAccountPublicKey;
 	}

package/tests/insurance/test.ts

@@ -0,0 +1,40 @@
+import { BN, ZERO, timeRemainingUntilUpdate, ONE } from '../../src';
+// import { mockPerpMarkets } from '../dlob/helpers';
+
+import { assert } from '../../src/assert/assert';
+
+describe('Insurance Tests', () => {
+	it('time remaining updates', () => {
+		const now = new BN(1683576852);
+		const lastUpdate = new BN(1683576000);
+		const period = new BN(3600); //hourly
+
+		let tr;
+		// console.log(now.sub(lastUpdate).toString());
+
+		tr = timeRemainingUntilUpdate(now, lastUpdate, period);
+		// console.log(tr.toString());
+		assert(tr.eq(new BN('2748')));
+
+		tr = timeRemainingUntilUpdate(now, lastUpdate.sub(period), period);
+		// console.log(tr.toString());
+		assert(tr.eq(ZERO));
+
+		const tooLateUpdate = lastUpdate.sub(period.div(new BN(3)).add(ONE));
+		tr = timeRemainingUntilUpdate(
+			tooLateUpdate.add(ONE),
+			tooLateUpdate,
+			period
+		);
+		// console.log(tr.toString());
+		assert(tr.eq(new BN('4800')));
+
+		tr = timeRemainingUntilUpdate(now, lastUpdate.add(ONE), period);
+		// console.log(tr.toString());
+		assert(tr.eq(new BN('2748')));
+
+		tr = timeRemainingUntilUpdate(now, lastUpdate.sub(ONE), period);
+		// console.log(tr.toString());
+		assert(tr.eq(new BN('2748')));
+	});
+});