@drift-labs/sdk 0.1.36-master.3 → 0.1.36-master.6

package/lib/tx/retryTxSender.d.ts

@@ -1,16 +1,16 @@
 /// <reference types="node" />
 import { TxSender } from './types';
 import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection } from '@solana/web3.js';
-import { Provider } from '@project-serum/anchor';
+import { AnchorProvider } from '@project-serum/anchor';
 declare type ResolveReference = {
     resolve?: () => void;
 };
 export declare class RetryTxSender implements TxSender {
-    provider: Provider;
+    provider: AnchorProvider;
     timeout: number;
     retrySleep: number;
     additionalConnections: Connection[];
-    constructor(provider: Provider, timeout?: number, retrySleep?: number, additionalConnections?: Connection[]);
+    constructor(provider: AnchorProvider, timeout?: number, retrySleep?: number, additionalConnections?: Connection[]);
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TransactionSignature>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
     confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.36-master.3",
+	"version": "0.1.36-master.6",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -28,7 +28,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@project-serum/anchor": "0.19.1-beta.1",
+		"@project-serum/anchor": "0.24.2",
 		"@pythnetwork/client": "^2.5.1",
 		"@solana/spl-token": "^0.1.6",
 		"@solana/web3.js": "^1.22.0",

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/accounts/webSocketAccountSubscriber.ts

@@ -1,5 +1,5 @@
 import { AccountData, AccountSubscriber } from './types';
-import { Program } from '@project-serum/anchor';
+import { AnchorProvider, Program } from '@project-serum/anchor';
 import { AccountInfo, Context, PublicKey } from '@solana/web3.js';
 import { capitalize } from './utils';
 import * as Buffer from 'buffer';
@@ -36,7 +36,7 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 			(accountInfo, context) => {
 				this.handleRpcResponse(context, accountInfo);
 			},
-			this.program.provider.opts.commitment
+			(this.program.provider as AnchorProvider).opts.commitment
 		);
 	}
 
@@ -44,7 +44,7 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 		const rpcResponse =
 			await this.program.provider.connection.getAccountInfoAndContext(
 				this.accountPublicKey,
-				this.program.provider.opts.commitment
+				(this.program.provider as AnchorProvider).opts.commitment
 			);
 		this.handleRpcResponse(rpcResponse.context, rpcResponse?.value);
 	}

package/src/admin.ts

@@ -12,7 +12,7 @@ import {
 	OracleSource,
 	OrderFillerRewardStructure,
 } from './types';
-import { BN, Provider } from '@project-serum/anchor';
+import { BN, AnchorProvider } from '@project-serum/anchor';
 import * as anchor from '@project-serum/anchor';
 import {
 	getClearingHouseStateAccountPublicKey,
@@ -34,7 +34,7 @@ export class Admin extends ClearingHouse {
 		connection: Connection,
 		wallet: IWallet,
 		clearingHouseProgramId: PublicKey,
-		opts: ConfirmOptions = Provider.defaultOptions()
+		opts: ConfirmOptions = AnchorProvider.defaultOptions()
 	): Admin {
 		const config = getWebSocketClearingHouseConfig(
 			connection,

package/src/clearingHouse.ts

@@ -1,4 +1,4 @@
-import { BN, Idl, Program, Provider } from '@project-serum/anchor';
+import { AnchorProvider, BN, Idl, Program } from '@project-serum/anchor';
 import {
 	ASSOCIATED_TOKEN_PROGRAM_ID,
 	Token,
@@ -71,7 +71,7 @@ export class ClearingHouse {
 	connection: Connection;
 	wallet: IWallet;
 	public program: Program;
-	provider: Provider;
+	provider: AnchorProvider;
 	opts?: ConfirmOptions;
 	accountSubscriber: ClearingHouseAccountSubscriber;
 	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
@@ -98,7 +98,7 @@ export class ClearingHouse {
 		connection: Connection,
 		wallet: IWallet,
 		clearingHouseProgramId: PublicKey,
-		opts: ConfirmOptions = Provider.defaultOptions()
+		opts: ConfirmOptions = AnchorProvider.defaultOptions()
 	): ClearingHouse {
 		const config = getWebSocketClearingHouseConfig(
 			connection,
@@ -245,7 +245,11 @@ export class ClearingHouse {
 	 * @param newWallet
 	 */
 	public updateWallet(newWallet: IWallet): void {
-		const newProvider = new Provider(this.connection, newWallet, this.opts);
+		const newProvider = new AnchorProvider(
+			this.connection,
+			newWallet,
+			this.opts
+		);
 		const newProgram = new Program(
 			clearingHouseIDL as Idl,
 			this.program.programId,
@@ -503,7 +507,7 @@ export class ClearingHouse {
 			.add(initializeUserOrdersAccountIx)
 			.add(depositCollateralIx);
 
-		const txSig = await this.program.provider.send(tx, [userPositionsAccount]);
+		const txSig = await this.txSender.send(tx, [userPositionsAccount]);
 
 		return [txSig, userAccountPublicKey];
 	}
@@ -538,7 +542,9 @@ export class ClearingHouse {
 			.add(initializeUserOrdersAccountIx)
 			.add(depositCollateralIx);
 
-		const txSig = await this.program.provider.send(tx, [userPositionsAccount]);
+		const txSig = await this.program.provider.sendAndConfirm(tx, [
+			userPositionsAccount,
+		]);
 
 		return [txSig, userAccountPublicKey];
 	}
@@ -911,17 +917,19 @@ export class ClearingHouse {
 	}
 
 	public async cancelAllOrders(
-		oracles?: PublicKey[]
+		oracles?: PublicKey[],
+		bestEffort?: boolean
 	): Promise<TransactionSignature> {
 		return await this.txSender.send(
-			wrapInTx(await this.getCancelAllOrdersIx(oracles)),
+			wrapInTx(await this.getCancelAllOrdersIx(oracles, bestEffort)),
 			[],
 			this.opts
 		);
 	}
 
 	public async getCancelAllOrdersIx(
-		oracles: PublicKey[]
+		oracles: PublicKey[],
+		bestEffort?: boolean
 	): Promise<TransactionInstruction> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 		const userAccount = await this.getUserAccount();
@@ -938,7 +946,7 @@ export class ClearingHouse {
 			});
 		}
 
-		return await this.program.instruction.cancelAllOrders({
+		return await this.program.instruction.cancelAllOrders(bestEffort, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
@@ -955,6 +963,69 @@ export class ClearingHouse {
 		});
 	}
 
+	public async cancelOrdersByMarketAndSide(
+		oracles?: PublicKey[],
+		bestEffort?: boolean,
+		marketIndexOnly?: BN,
+		directionOnly?: PositionDirection
+	): Promise<TransactionSignature> {
+		return await this.txSender.send(
+			wrapInTx(
+				await this.getCancelOrdersByMarketAndSideIx(
+					oracles,
+					bestEffort,
+					marketIndexOnly,
+					directionOnly
+				)
+			),
+			[],
+			this.opts
+		);
+	}
+
+	public async getCancelOrdersByMarketAndSideIx(
+		oracles: PublicKey[],
+		bestEffort?: boolean,
+		marketIndexOnly?: BN,
+		directionOnly?: PositionDirection
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const userAccount = await this.getUserAccount();
+
+		const state = this.getStateAccount();
+		const orderState = this.getOrderStateAccount();
+
+		const remainingAccounts = [];
+		for (const oracle of oracles) {
+			remainingAccounts.push({
+				pubkey: oracle,
+				isWritable: false,
+				isSigner: false,
+			});
+		}
+
+		return await this.program.instruction.cancelOrdersByMarketAndSide(
+			bestEffort,
+			marketIndexOnly,
+			directionOnly,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					user: userAccountPublicKey,
+					authority: this.wallet.publicKey,
+					markets: state.markets,
+					userOrders: await this.getUserOrdersAccountPublicKey(),
+					userPositions: userAccount.positions,
+					fundingPaymentHistory: state.fundingPaymentHistory,
+					fundingRateHistory: state.fundingRateHistory,
+					orderState: await this.getOrderStatePublicKey(),
+					orderHistory: orderState.orderHistory,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
 	public async fillOrder(
 		userAccountPublicKey: PublicKey,
 		userOrdersAccountPublicKey: PublicKey,

package/src/examples/makeTradeExample.ts

@@ -1,4 +1,4 @@
-import { BN, Provider } from '@project-serum/anchor';
+import { AnchorProvider, BN } from '@project-serum/anchor';
 import { Wallet } from '..';
 import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
@@ -43,7 +43,11 @@ const main = async () => {
 	const connection = new Connection(rpcAddress);
 
 	// Set up the Provider
-	const provider = new Provider(connection, wallet, Provider.defaultOptions());
+	const provider = new AnchorProvider(
+		connection,
+		wallet,
+		AnchorProvider.defaultOptions()
+	);
 
 	// Check SOL Balance
 	const lamportsBalance = await connection.getBalance(wallet.publicKey);

package/src/factory/clearingHouse.ts

@@ -2,7 +2,7 @@ import { ConfirmOptions, Connection, PublicKey } from '@solana/web3.js';
 import { IWallet } from '../types';
 import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
 import { TxSender } from '../tx/types';
-import { Idl, Program, Provider } from '@project-serum/anchor';
+import { AnchorProvider, Idl, Program } from '@project-serum/anchor';
 import { ClearingHouse } from '../clearingHouse';
 import clearingHouseIDL from '../idl/clearing_house.json';
 import { WebSocketClearingHouseAccountSubscriber } from '../accounts/webSocketClearingHouseAccountSubscriber';
@@ -53,7 +53,7 @@ export function getWebSocketClearingHouseConfig(
 	connection: Connection,
 	wallet: IWallet,
 	programID: PublicKey,
-	opts: ConfirmOptions = Provider.defaultOptions(),
+	opts: ConfirmOptions = AnchorProvider.defaultOptions(),
 	txSenderConfig?: TxSenderConfig
 ): WebSocketClearingHouseConfiguration {
 	return {
@@ -71,7 +71,7 @@ export function getPollingClearingHouseConfig(
 	wallet: IWallet,
 	programID: PublicKey,
 	accountLoader: BulkAccountLoader,
-	opts: ConfirmOptions = Provider.defaultOptions(),
+	opts: ConfirmOptions = AnchorProvider.defaultOptions(),
 	txSenderConfig?: TxSenderConfig
 ): PollingClearingHouseConfiguration {
 	return {
@@ -86,7 +86,11 @@ export function getPollingClearingHouseConfig(
 }
 
 export function getClearingHouse(config: ClearingHouseConfig): ClearingHouse {
-	const provider = new Provider(config.connection, config.wallet, config.opts);
+	const provider = new AnchorProvider(
+		config.connection,
+		config.wallet,
+		config.opts
+	);
 	const program = new Program(
 		clearingHouseIDL as Idl,
 		config.programID,
@@ -126,7 +130,11 @@ export function getClearingHouse(config: ClearingHouseConfig): ClearingHouse {
 }
 
 export function getAdmin(config: ClearingHouseConfig): Admin {
-	const provider = new Provider(config.connection, config.wallet, config.opts);
+	const provider = new AnchorProvider(
+		config.connection,
+		config.wallet,
+		config.opts
+	);
 	const program = new Program(
 		clearingHouseIDL as Idl,
 		config.programID,

package/src/idl/clearing_house.json

@@ -726,7 +726,78 @@
           "isSigner": false
         }
       ],
-      "args": []
+      "args": [
+        {
+          "name": "bestEffort",
+          "type": "bool"
+        }
+      ]
+    },
+    {
+      "name": "cancelOrdersByMarketAndSide",
+      "accounts": [
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "orderState",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "user",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "markets",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "userPositions",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "userOrders",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "fundingPaymentHistory",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "orderHistory",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "bestEffort",
+          "type": "bool"
+        },
+        {
+          "name": "marketIndexOnly",
+          "type": "u64"
+        },
+        {
+          "name": "directionOnly",
+          "type": {
+            "defined": "PositionDirection"
+          }
+        }
+      ]
     },
     {
       "name": "expireOrders",

package/src/index.ts

@@ -26,6 +26,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/src/math/oracles.ts

@@ -0,0 +1,36 @@
+import { AMM, OracleGuardRails } from '../types';
+import { OraclePriceData } from '../oracles/types';
+import { ONE, ZERO } from '../constants/numericConstants';
+import { BN } from '../index';
+
+export function isOracleValid(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	oracleGuardRails: OracleGuardRails,
+	slot: number
+): boolean {
+	const isOraclePriceNonPositive = oraclePriceData.price.lt(ZERO);
+	const isOraclePriceTooVolatile =
+		oraclePriceData.price
+			.div(BN.max(ONE, amm.lastOraclePriceTwap))
+			.gt(oracleGuardRails.validity.tooVolatileRatio) ||
+		amm.lastOraclePriceTwap
+			.div(BN.max(ONE, oraclePriceData.price))
+			.gt(oracleGuardRails.validity.tooVolatileRatio);
+
+	const isConfidenceTooLarge = oraclePriceData.price
+		.div(BN.max(ONE, oraclePriceData.confidence))
+		.lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+
+	const oracleIsStale = oraclePriceData.slot
+		.sub(new BN(slot))
+		.gt(oracleGuardRails.validity.slotsBeforeStale);
+
+	return !(
+		!oraclePriceData.hasSufficientNumberOfDataPoints ||
+		oracleIsStale ||
+		isOraclePriceNonPositive ||
+		isOraclePriceTooVolatile ||
+		isConfidenceTooLarge
+	);
+}

package/src/math/trade.ts

@@ -7,7 +7,11 @@ import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	ZERO,
 } from '../constants/numericConstants';
-import { calculateMarkPrice } from './market';
+import {
+	calculateBidPrice,
+	calculateAskPrice,
+	calculateMarkPrice,
+} from './market';
 import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
@@ -16,6 +20,7 @@ import {
 	calculateSpreadReserves,
 } from './amm';
 import { squareRootBN } from './utils';
+import { isVariant } from '../types';
 
 const MAXPCT = new BN(1000); //percentage units are [0,1000] => [0,1]
 
@@ -37,6 +42,8 @@ export type PriceImpactUnit =
  * @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
@@ -51,9 +58,20 @@ export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
 	market: Market,
-	inputAssetType: AssetType = 'quote'
+	inputAssetType: AssetType = 'quote',
+	useSpread = true
 ): [BN, BN, BN, BN] {
-	const oldPrice = calculateMarkPrice(market);
+	let oldPrice: BN;
+
+	if (useSpread && market.amm.baseSpread > 0) {
+		if (isVariant(direction, 'long')) {
+			oldPrice = calculateAskPrice(market);
+		} else {
+			oldPrice = calculateBidPrice(market);
+		}
+	} else {
+		oldPrice = calculateMarkPrice(market);
+	}
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO, oldPrice, oldPrice];
 	}
@@ -61,7 +79,8 @@ export function calculateTradeSlippage(
 		direction,
 		amount,
 		market,
-		inputAssetType
+		inputAssetType,
+		useSpread
 	);
 
 	const entryPrice = calculatePrice(
@@ -70,10 +89,26 @@ export function calculateTradeSlippage(
 		market.amm.pegMultiplier
 	).mul(new BN(-1));
 
+	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
+	if (useSpread && market.amm.baseSpread > 0) {
+		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
+			market.amm,
+			direction
+		);
+		amm = {
+			baseAssetReserve,
+			quoteAssetReserve,
+			sqrtK: market.amm.sqrtK,
+			pegMultiplier: market.amm.pegMultiplier,
+		};
+	} else {
+		amm = market.amm;
+	}
+
 	const newPrice = calculatePrice(
-		market.amm.baseAssetReserve.sub(acquiredBase),
-		market.amm.quoteAssetReserve.sub(acquiredQuote),
-		market.amm.pegMultiplier
+		amm.baseAssetReserve.sub(acquiredBase),
+		amm.quoteAssetReserve.sub(acquiredQuote),
+		amm.pegMultiplier
 	);
 
 	if (direction == PositionDirection.SHORT) {
@@ -104,7 +139,7 @@ export function 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
  */
 export function calculateTradeAcquiredAmounts(
@@ -150,43 +185,63 @@ export function 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
  * ]
  */
 export function calculateTargetPriceTrade(
 	market: Market,
 	targetPrice: BN,
 	pct: BN = MAXPCT,
-	outputAssetType: AssetType = 'quote'
+	outputAssetType: AssetType = 'quote',
+	useSpread = true
 ): [PositionDirection, BN, BN, BN] {
 	assert(market.amm.baseAssetReserve.gt(ZERO));
 	assert(targetPrice.gt(ZERO));
 	assert(pct.lte(MAXPCT) && pct.gt(ZERO));
 
 	const markPriceBefore = calculateMarkPrice(market);
+	const bidPriceBefore = calculateBidPrice(market);
+	const askPriceBefore = 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 = PositionDirection.LONG;
 	} else {
 		const priceGap = markPriceBefore.sub(targetPrice);
 		const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
 		targetPrice = markPriceBefore.sub(priceGapScaled);
+		direction = PositionDirection.SHORT;
 	}
 
-	let direction;
 	let tradeSize;
 	let baseSize;
 
-	const baseAssetReserveBefore = market.amm.baseAssetReserve;
-	const quoteAssetReserveBefore = market.amm.quoteAssetReserve;
+	let baseAssetReserveBefore: BN;
+	let quoteAssetReserveBefore: BN;
+
+	if (useSpread && market.amm.baseSpread > 0) {
+		const { baseAssetReserve, quoteAssetReserve } = 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(MARK_PRICE_PRECISION);
@@ -196,7 +251,20 @@ export function calculateTargetPriceTrade(
 	const biasModifier = new 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 = PositionDirection.SHORT;
+		} else {
+			direction = PositionDirection.LONG;
+		}
+		tradeSize = ZERO;
+		return [direction, tradeSize, targetPrice, targetPrice];
+	} else if (markPriceBefore.gt(targetPrice)) {
 		// overestimate y2
 		baseAssetReserveAfter = squareRootBN(
 			k.div(targetPrice).mul(peg).div(PEG_PRECISION).sub(biasModifier)

package/src/mockUSDCFaucet.ts

@@ -1,5 +1,5 @@
 import * as anchor from '@project-serum/anchor';
-import { Idl, Program, Provider } from '@project-serum/anchor';
+import { AnchorProvider, Idl, Program } from '@project-serum/anchor';
 import {
 	AccountInfo,
 	ASSOCIATED_TOKEN_PROGRAM_ID,
@@ -25,7 +25,7 @@ export class MockUSDCFaucet {
 	connection: Connection;
 	wallet: IWallet;
 	public program: Program;
-	provider: Provider;
+	provider: AnchorProvider;
 	opts?: ConfirmOptions;
 
 	public constructor(
@@ -36,8 +36,8 @@ export class MockUSDCFaucet {
 	) {
 		this.connection = connection;
 		this.wallet = wallet;
-		this.opts = opts || Provider.defaultOptions();
-		const provider = new Provider(connection, wallet, this.opts);
+		this.opts = opts || AnchorProvider.defaultOptions();
+		const provider = new AnchorProvider(connection, wallet, this.opts);
 		this.provider = provider;
 		this.program = new Program(mockUSDCFaucetIDL as Idl, programId, provider);
 	}
@@ -140,7 +140,7 @@ export class MockUSDCFaucet {
 				amount
 			);
 		const tx = new Transaction().add(createAssociatedAccountIx).add(mintToTx);
-		const txSig = await this.program.provider.send(tx, [], this.opts);
+		const txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
 		return [associatedTokenPublicKey, txSig];
 	}