@drift-labs/sdk 2.23.0 → 2.25.0-beta.0

package/src/driftClient.ts

@@ -4,7 +4,7 @@ import {
 	Idl,
 	Program,
 	ProgramAccount,
-} from '@project-serum/anchor';
+} from '@coral-xyz/anchor';
 import bs58 from 'bs58';
 import {
 	ASSOCIATED_TOKEN_PROGRAM_ID,
@@ -33,13 +33,12 @@ import {
 	isVariant,
 	ReferrerNameAccount,
 	OrderTriggerCondition,
-	isOneOfVariant,
-	PostOnlyParams,
 	SpotBalanceType,
 	PerpMarketExtendedInfo,
 	UserStatsAccount,
+	ModifyOrderParams,
 } from './types';
-import * as anchor from '@project-serum/anchor';
+import * as anchor from '@coral-xyz/anchor';
 import driftIDL from './idl/drift.json';
 
 import {
@@ -766,6 +765,24 @@ export class DriftClient {
 		);
 	}
 
+	public async getUserAccountsAndAddressesForAuthority(
+		authority: PublicKey
+	): Promise<ProgramAccount<UserAccount>[]> {
+		const programAccounts = await this.program.account.user.all([
+			{
+				memcmp: {
+					offset: 8,
+					/** data to match, as base-58 encoded string and limited to less than 129 bytes */
+					bytes: bs58.encode(authority.toBuffer()),
+				},
+			},
+		]);
+
+		return programAccounts.map(
+			(programAccount) => programAccount as ProgramAccount<UserAccount>
+		);
+	}
+
 	public async getUserAccountsForAuthority(
 		authority: PublicKey
 	): Promise<UserAccount[]> {
@@ -3372,221 +3389,205 @@ export class DriftClient {
 	/**
 	 * Modifies an open order (spot or perp) by closing it and replacing it with a new order.
 	 * @param orderId: The open order to modify
-	 * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
-	 * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
-	 * @param newOraclePriceOffset: The new oracle price offset for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
-	 * @param newOrderType: Optional - New order type for the order.
+	 * @param newDirection: The new direction for the order
+	 * @param newBaseAmount: The new base amount for the order
+	 * @param newLimitPice: The new limit price for the order
+	 * @param newOraclePriceOffset: The new oracle price offset for the order
 	 * @param newTriggerPrice: Optional - Thew new trigger price for the order.
-	 * @param isSpot: Optional - Set to true if the order is a spot order
-	 * @param auctionDuration: Only required if order type changed to market from something else
-	 * @param auctionStartPrice: Only required if order type changed to market from something else
-	 * @param auctionEndPrice: Only required if order type changed to market from something else
+	 * @param auctionDuration:
+	 * @param auctionStartPrice:
+	 * @param auctionEndPrice:
+	 * @param reduceOnly:
+	 * @param postOnly:
+	 * @param immediateOrCancel:
+	 * @param maxTs:
 	 * @returns
 	 */
 	public async modifyOrder({
 		orderId,
+		newDirection,
 		newBaseAmount,
 		newLimitPrice,
 		newOraclePriceOffset,
-		newOrderType,
 		newTriggerPrice,
 		newTriggerCondition,
-		isSpot,
 		auctionDuration,
 		auctionStartPrice,
 		auctionEndPrice,
+		reduceOnly,
+		postOnly,
+		immediateOrCancel,
+		maxTs,
+		txParams,
 	}: {
 		orderId: number;
+		newDirection?: PositionDirection;
 		newBaseAmount?: BN;
 		newLimitPrice?: BN;
 		newOraclePriceOffset?: number;
-		newOrderType?: OrderType;
 		newTriggerPrice?: BN;
 		newTriggerCondition?: OrderTriggerCondition;
-		isSpot?: boolean;
 		auctionDuration?: number;
 		auctionStartPrice?: BN;
 		auctionEndPrice?: BN;
+		reduceOnly?: boolean;
+		postOnly?: boolean;
+		immediateOrCancel?: boolean;
+		maxTs?: BN;
+		txParams?: TxParams;
 	}): Promise<TransactionSignature> {
-		if (!newBaseAmount && !newLimitPrice && !newOraclePriceOffset) {
-			throw new Error(
-				`Must provide newBaseAmount or newLimitPrice or newOraclePriceOffset to modify order`
-			);
-		}
-
-		const openOrder = this.getUser().getOrder(orderId);
-		if (!openOrder) {
-			throw new Error(`No open order with id ${orderId.toString()}`);
-		}
-		const cancelOrderIx = await this.getCancelOrderIx(orderId);
-
-		const orderTypeHasTrigger = newOrderType
-			? isOneOfVariant(newOrderType, ['triggerlimit', 'triggerMarket'])
-			: isOneOfVariant(openOrder.orderType, ['triggerLimit', 'triggerMarket']);
-		const orderTypeHasLimitPrice = newOrderType
-			? isOneOfVariant(newOrderType, ['triggerLimit', 'limit'])
-			: isOneOfVariant(openOrder.orderType, ['triggerLimit', 'limit']);
-
-		const newOrderParams: OptionalOrderParams = {
-			orderType: newOrderType || openOrder.orderType,
-			marketType: openOrder.marketType,
-			direction: openOrder.direction,
-			baseAssetAmount: newBaseAmount || openOrder.baseAssetAmount,
-			price: orderTypeHasLimitPrice
-				? newLimitPrice || openOrder.price
-				: undefined,
-			marketIndex: openOrder.marketIndex,
-			reduceOnly: openOrder.reduceOnly,
-			postOnly: openOrder.postOnly
-				? PostOnlyParams.MUST_POST_ONLY
-				: PostOnlyParams.NONE,
-			immediateOrCancel: openOrder.immediateOrCancel,
-			triggerPrice: orderTypeHasTrigger
-				? newTriggerPrice || openOrder.triggerPrice
-				: undefined,
-			triggerCondition: orderTypeHasTrigger
-				? newTriggerCondition || openOrder.triggerCondition
-				: undefined,
-			oraclePriceOffset: newOraclePriceOffset || openOrder.oraclePriceOffset,
-			auctionDuration: auctionDuration ?? openOrder.auctionDuration,
-			maxTs: openOrder.maxTs,
-			auctionStartPrice: auctionStartPrice || openOrder.auctionStartPrice,
-			auctionEndPrice: auctionEndPrice || openOrder.auctionEndPrice,
-			userOrderId: openOrder.userOrderId,
+		const orderParams: ModifyOrderParams = {
+			baseAssetAmount: newBaseAmount || null,
+			direction: newDirection || null,
+			price: newLimitPrice || null,
+			oraclePriceOffset: newOraclePriceOffset || null,
+			triggerPrice: newTriggerPrice || null,
+			triggerCondition: newTriggerCondition || null,
+			auctionDuration: auctionDuration || null,
+			auctionStartPrice: auctionStartPrice || null,
+			auctionEndPrice: auctionEndPrice || null,
+			reduceOnly: reduceOnly || null,
+			postOnly: postOnly || null,
+			immediateOrCancel: immediateOrCancel || null,
+			maxTs: maxTs || null,
 		};
-		const placeOrderIx = isSpot
-			? await this.getPlaceSpotOrderIx(newOrderParams)
-			: await this.getPlacePerpOrderIx(newOrderParams);
 
-		const tx = new Transaction();
-		tx.add(
-			ComputeBudgetProgram.setComputeUnitLimit({
-				units: 1_000_000,
-			})
+		const { txSig } = await this.sendTransaction(
+			wrapInTx(
+				await this.getModifyOrderIx(orderId, orderParams),
+				txParams?.computeUnits,
+				txParams?.computeUnitsPrice
+			),
+			[],
+			this.opts
 		);
-		tx.add(cancelOrderIx);
-		tx.add(placeOrderIx);
-		const { txSig, slot } = await this.sendTransaction(tx, [], this.opts);
+		return txSig;
+	}
 
-		if (isSpot) {
-			this.spotMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
-			this.spotMarketLastSlotCache.set(QUOTE_SPOT_MARKET_INDEX, slot);
-		} else {
-			this.perpMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
-		}
+	public async getModifyOrderIx(
+		orderId: number,
+		orderParams: ModifyOrderParams
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		return txSig;
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+		});
+
+		return await this.program.instruction.modifyOrder(orderId, orderParams, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
+				authority: this.wallet.publicKey,
+			},
+			remainingAccounts,
+		});
 	}
 
 	/**
 	 * Modifies an open order by closing it and replacing it with a new order.
 	 * @param userOrderId: The open order to modify
-	 * @param newBaseAmount: The new base amount for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
-	 * @param newLimitPice: The new limit price for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
-	 * @param newOraclePriceOffset: The new oracle price offset for the order. One of [newBaseAmount|newLimitPrice|newOraclePriceOffset] must be provided.
-	 * @param newOrderType: Optional - New order type for the order.
+	 * @param newDirection: The new direction for the order
+	 * @param newBaseAmount: The new base amount for the order
+	 * @param newLimitPice: The new limit price for the order
+	 * @param newOraclePriceOffset: The new oracle price offset for the order
 	 * @param newTriggerPrice: Optional - Thew new trigger price for the order.
-	 * @param isSpot: Set to true if the order is a spot order
 	 * @param auctionDuration: Only required if order type changed to market from something else
 	 * @param auctionStartPrice: Only required if order type changed to market from something else
 	 * @param auctionEndPrice: Only required if order type changed to market from something else
+	 * @param reduceOnly:
+	 * @param postOnly:
+	 * @param immediateOrCancel:
+	 * @param maxTs:
 	 * @returns
 	 */
 	public async modifyOrderByUserOrderId({
 		userOrderId,
+		newDirection,
 		newBaseAmount,
 		newLimitPrice,
 		newOraclePriceOffset,
-		newOrderType,
 		newTriggerPrice,
 		newTriggerCondition,
-		isSpot,
 		auctionDuration,
 		auctionStartPrice,
 		auctionEndPrice,
+		reduceOnly,
+		postOnly,
+		immediateOrCancel,
+		maxTs,
+		txParams,
 	}: {
 		userOrderId: number;
+		newDirection?: PositionDirection;
 		newBaseAmount?: BN;
 		newLimitPrice?: BN;
 		newOraclePriceOffset?: number;
-		newOrderType?: OrderType;
 		newTriggerPrice?: BN;
 		newTriggerCondition?: OrderTriggerCondition;
-		isSpot?: boolean;
 		auctionDuration?: number;
 		auctionStartPrice?: BN;
 		auctionEndPrice?: BN;
+		reduceOnly?: boolean;
+		postOnly?: boolean;
+		immediateOrCancel?: boolean;
+		maxTs?: BN;
+		txParams?: TxParams;
 	}): Promise<TransactionSignature> {
-		if (!newBaseAmount && !newLimitPrice && !newOraclePriceOffset) {
-			throw new Error(
-				`Must provide newBaseAmount or newLimitPrice or newOraclePriceOffset to modify order`
-			);
-		}
-
-		const openOrder = this.getUser().getOrderByUserOrderId(userOrderId);
-		if (!openOrder) {
-			throw new Error(
-				`No open order with user order id ${userOrderId.toString()}`
-			);
-		}
-		const cancelOrderIx = await this.getCancelOrderByUserIdIx(userOrderId);
-
-		const orderTypeHasTrigger = newOrderType
-			? isOneOfVariant(newOrderType, ['triggerlimit', 'triggerMarket'])
-			: isOneOfVariant(openOrder.orderType, ['triggerLimit', 'triggerMarket']);
-		const orderTypeHasLimitPrice = newOrderType
-			? isOneOfVariant(newOrderType, ['triggerLimit', 'limit'])
-			: isOneOfVariant(openOrder.orderType, ['triggerLimit', 'limit']);
-
-		const newOrderParams: OptionalOrderParams = {
-			orderType: newOrderType || openOrder.orderType,
-			marketType: openOrder.marketType,
-			direction: openOrder.direction,
-			baseAssetAmount: newBaseAmount || openOrder.baseAssetAmount,
-			price: orderTypeHasLimitPrice
-				? newLimitPrice || openOrder.price
-				: undefined,
-			marketIndex: openOrder.marketIndex,
-			reduceOnly: openOrder.reduceOnly,
-			postOnly: openOrder.postOnly
-				? PostOnlyParams.MUST_POST_ONLY
-				: PostOnlyParams.NONE,
-			immediateOrCancel: openOrder.immediateOrCancel,
-			triggerPrice: orderTypeHasTrigger
-				? newTriggerPrice || openOrder.triggerPrice
-				: undefined,
-			triggerCondition: orderTypeHasTrigger
-				? newTriggerCondition || openOrder.triggerCondition
-				: undefined,
-			oraclePriceOffset: newOraclePriceOffset || openOrder.oraclePriceOffset,
-			auctionDuration: auctionDuration || openOrder.auctionDuration,
-			maxTs: openOrder.maxTs,
-			auctionStartPrice: auctionStartPrice || openOrder.auctionStartPrice,
-			auctionEndPrice: auctionEndPrice || openOrder.auctionEndPrice,
-			userOrderId: openOrder.userOrderId,
+		const orderParams: ModifyOrderParams = {
+			baseAssetAmount: newBaseAmount || null,
+			direction: newDirection || null,
+			price: newLimitPrice || null,
+			oraclePriceOffset: newOraclePriceOffset || null,
+			triggerPrice: newTriggerPrice || null,
+			triggerCondition: newTriggerCondition || null,
+			auctionDuration: auctionDuration || null,
+			auctionStartPrice: auctionStartPrice || null,
+			auctionEndPrice: auctionEndPrice || null,
+			reduceOnly: reduceOnly || null,
+			postOnly: postOnly || null,
+			immediateOrCancel: immediateOrCancel || null,
+			maxTs: maxTs || null,
 		};
-		const placeOrderIx = isSpot
-			? await this.getPlaceSpotOrderIx(newOrderParams)
-			: await this.getPlacePerpOrderIx(newOrderParams);
 
-		const tx = new Transaction();
-		tx.add(
-			ComputeBudgetProgram.setComputeUnitLimit({
-				units: 1_000_000,
-			})
+		const { txSig } = await this.sendTransaction(
+			wrapInTx(
+				await this.getModifyOrderByUserIdIx(userOrderId, orderParams),
+				txParams?.computeUnits,
+				txParams?.computeUnitsPrice
+			),
+			[],
+			this.opts
 		);
-		tx.add(cancelOrderIx);
-		tx.add(placeOrderIx);
-		const { txSig, slot } = await this.sendTransaction(tx, [], this.opts);
+		return txSig;
+	}
 
-		if (isSpot) {
-			this.spotMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
-			this.spotMarketLastSlotCache.set(QUOTE_SPOT_MARKET_INDEX, slot);
-		} else {
-			this.perpMarketLastSlotCache.set(newOrderParams.marketIndex, slot);
-		}
+	public async getModifyOrderByUserIdIx(
+		userOrderId: number,
+		orderParams: ModifyOrderParams
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		return txSig;
+		const remainingAccounts = this.getRemainingAccounts({
+			userAccounts: [this.getUserAccount()],
+			useMarketLastSlotCache: true,
+		});
+
+		return await this.program.instruction.modifyOrderByUserId(
+			userOrderId,
+			orderParams,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user: userAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
+					authority: this.wallet.publicKey,
+				},
+				remainingAccounts,
+			}
+		);
 	}
 
 	public async settlePNLs(
@@ -4205,11 +4206,11 @@ export class DriftClient {
 		);
 	}
 
-	public async addInsuranceFundStake(
+	public async getAddInsuranceFundStakeIx(
 		marketIndex: number,
 		amount: BN,
 		collateralAccountPublicKey: PublicKey
-	): Promise<TransactionSignature> {
+	): Promise<TransactionInstruction> {
 		const spotMarket = this.getSpotMarketAccount(marketIndex);
 		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
 			this.program.programId,
@@ -4223,7 +4224,7 @@ export class DriftClient {
 			writableSpotMarketIndexes: [marketIndex],
 		});
 
-		const tx = await this.program.transaction.addInsuranceFundStake(
+		const ix = this.program.instruction.addInsuranceFundStake(
 			marketIndex,
 			amount,
 			{
@@ -4243,7 +4244,88 @@ export class DriftClient {
 			}
 		);
 
-		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+		return ix;
+	}
+
+	/**
+	 * Add to an insurance fund stake and optionally initialize the account
+	 */
+	public async addInsuranceFundStake({
+		marketIndex,
+		amount,
+		collateralAccountPublicKey,
+		initializeStakeAccount,
+	}: {
+		/**
+		 * Spot market index
+		 */
+		marketIndex: number;
+		amount: BN;
+		/**
+		 * The account where the funds to stake come from. Usually an associated token account
+		 */
+		collateralAccountPublicKey: PublicKey;
+		/**
+		 * Add instructions to initialize the staking account -- required if its the first time the currrent authority has staked in this market
+		 */
+		initializeStakeAccount?: boolean;
+	}): Promise<TransactionSignature> {
+		const tx = new Transaction();
+
+		const additionalSigners: Array<Signer> = [];
+		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
+		const isSolMarket = spotMarketAccount.mint.equals(WRAPPED_SOL_MINT);
+		const createWSOLTokenAccount =
+			isSolMarket && collateralAccountPublicKey.equals(this.wallet.publicKey);
+
+		let tokenAccount;
+
+		if (createWSOLTokenAccount) {
+			const { ixs, signers, pubkey } =
+				await this.getWrappedSolAccountCreationIxs(amount, true);
+			tokenAccount = pubkey;
+			ixs.forEach((ix) => {
+				tx.add(ix);
+			});
+
+			signers.forEach((signer) => additionalSigners.push(signer));
+		} else {
+			tokenAccount = collateralAccountPublicKey;
+		}
+
+		if (initializeStakeAccount) {
+			const initializeIx = await this.getInitializeInsuranceFundStakeIx(
+				marketIndex
+			);
+			tx.add(initializeIx);
+		}
+
+		const addFundsIx = await this.getAddInsuranceFundStakeIx(
+			marketIndex,
+			amount,
+			tokenAccount
+		);
+
+		tx.add(addFundsIx);
+
+		if (createWSOLTokenAccount) {
+			tx.add(
+				Token.createCloseAccountInstruction(
+					TOKEN_PROGRAM_ID,
+					tokenAccount,
+					this.wallet.publicKey,
+					this.wallet.publicKey,
+					[]
+				)
+			);
+		}
+
+		const { txSig } = await this.sendTransaction(
+			tx,
+			additionalSigners,
+			this.opts
+		);
+
 		return txSig;
 	}
 
@@ -4324,12 +4406,33 @@ export class DriftClient {
 		marketIndex: number,
 		collateralAccountPublicKey: PublicKey
 	): Promise<TransactionSignature> {
+		const tx = new Transaction();
 		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
 		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
 			this.program.programId,
 			this.wallet.publicKey,
 			marketIndex
 		);
+		const tokenAccount = collateralAccountPublicKey;
+
+		// Todo wsol remove iF stake... how do we determine the amount?
+		// const amount = // get balance here...?
+
+		// const additionalSigners: Array<Signer> = [];
+		// const isSolMarket = spotMarketAccount.mint.equals(WRAPPED_SOL_MINT);
+		// const createWSOLTokenAccount =
+		// 	isSolMarket && collateralAccountPublicKey.equals(this.wallet.publicKey);
+
+		// if (createWSOLTokenAccount) {
+		// 	const { ixs, signers, pubkey } =
+		// 		await this.getWrappedSolAccountCreationIxs(amount, true);
+		// 	tokenAccount = pubkey;
+		// 	ixs.forEach((ix) => {
+		// 		tx.add(ix);
+		// 	});
+
+		// 	signers.forEach((signer) => additionalSigners.push(signer));
+		// }
 
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts: [this.getUserAccount()],
@@ -4337,9 +4440,8 @@ export class DriftClient {
 			writableSpotMarketIndexes: [marketIndex],
 		});
 
-		const tx = await this.program.transaction.removeInsuranceFundStake(
-			marketIndex,
-			{
+		const removeStakeIx =
+			await this.program.instruction.removeInsuranceFundStake(marketIndex, {
 				accounts: {
 					state: await this.getStatePublicKey(),
 					spotMarket: spotMarketAccount.pubkey,
@@ -4348,12 +4450,13 @@ export class DriftClient {
 					authority: this.wallet.publicKey,
 					insuranceFundVault: spotMarketAccount.insuranceFund.vault,
 					driftSigner: this.getSignerPublicKey(),
-					userTokenAccount: collateralAccountPublicKey,
+					userTokenAccount: tokenAccount,
 					tokenProgram: TOKEN_PROGRAM_ID,
 				},
 				remainingAccounts,
-			}
-		);
+			});
+
+		tx.add(removeStakeIx);
 
 		const { txSig } = await this.sendTransaction(tx, [], this.opts);
 		return txSig;

package/src/events/eventSubscriber.ts

@@ -1,5 +1,5 @@
 import { Connection, TransactionSignature } from '@solana/web3.js';
-import { Program } from '@project-serum/anchor';
+import { Program } from '@coral-xyz/anchor';
 import {
 	DefaultEventSubscriptionOptions,
 	EventSubscriptionOptions,
@@ -164,7 +164,11 @@ export class EventSubscriber {
 	): WrappedEvents {
 		const records = [];
 		// @ts-ignore
-		this.program._events._eventParser.parseLogs(logs, (event) => {
+		const eventGenerator = this.program._events._eventParser.parseLogs(
+			logs,
+			false
+		);
+		for (const event of eventGenerator) {
 			const expectRecordType = this.eventListMap.has(event.name);
 			if (expectRecordType) {
 				event.data.txSig = txSig;
@@ -172,7 +176,7 @@ export class EventSubscriber {
 				event.data.eventType = event.name;
 				records.push(event.data);
 			}
-		});
+		}
 		return records;
 	}
 

package/src/events/fetchLogs.ts

@@ -1,4 +1,4 @@
-import { Program } from '@project-serum/anchor';
+import { Program } from '@coral-xyz/anchor';
 import {
 	Connection,
 	Finality,
@@ -120,12 +120,16 @@ export class LogParser {
 	public parseEventsFromLogs(event: Log): WrappedEvents {
 		const records: WrappedEvents = [];
 		// @ts-ignore
-		this.program._events._eventParser.parseLogs(event.logs, (eventLog) => {
+		const eventGenerator = this.program._events._eventParser.parseLogs(
+			event.logs,
+			false
+		);
+		for (const eventLog of eventGenerator) {
 			eventLog.data.txSig = event.txSig;
 			eventLog.data.slot = event.slot;
 			eventLog.data.eventType = eventLog.name;
 			records.push(eventLog.data);
-		});
+		}
 		return records;
 	}
 }

package/src/examples/loadDlob.ts

@@ -1,4 +1,4 @@
-import { AnchorProvider } from '@project-serum/anchor';
+import { AnchorProvider } from '@coral-xyz/anchor';
 import { DLOB, UserMap, Wallet } from '..';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import {

package/src/examples/makeTradeExample.ts

@@ -1,4 +1,4 @@
-import { AnchorProvider, BN } from '@project-serum/anchor';
+import { AnchorProvider, BN } from '@coral-xyz/anchor';
 import {
 	BASE_PRECISION,
 	calculateBidAskPrice,

package/src/factory/bigNum.ts

@@ -1,4 +1,4 @@
-import { BN } from '@project-serum/anchor';
+import { BN } from '@coral-xyz/anchor';
 import { assert } from '../assert/assert';
 import { ZERO } from './../constants/numericConstants';
 

package/src/factory/oracleClient.ts

@@ -4,7 +4,7 @@ import { OracleClient } from '../oracles/types';
 import { PythClient } from '../oracles/pythClient';
 // import { SwitchboardClient } from '../oracles/switchboardClient';
 import { QuoteAssetOracleClient } from '../oracles/quoteAssetOracleClient';
-import { BN } from '@project-serum/anchor';
+import { BN } from '@coral-xyz/anchor';
 
 export function getOracleClient(
 	oracleSource: OracleSource,