@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.0

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { Market, PositionDirection } from '../types';
+import { MarketAccount, PositionDirection, SwapDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -17,10 +17,12 @@ import {
 	calculatePrice,
 	getSwapDirection,
 	AssetType,
-	calculateSpreadReserves,
+	calculateUpdatedAMMSpreadReserves,
+	calculateQuoteAssetAmountSwapped,
 } from './amm';
 import { squareRootBN } from './utils';
 import { isVariant } from '../types';
+import { OraclePriceData } from '../oracles/types';
 
 const MAXPCT = new BN(1000); //percentage units are [0,1000] => [0,1]
 
@@ -57,20 +59,21 @@ export type PriceImpactUnit =
 export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
-	market: Market,
+	market: MarketAccount,
 	inputAssetType: AssetType = 'quote',
+	oraclePriceData?: OraclePriceData,
 	useSpread = true
 ): [BN, BN, BN, BN] {
 	let oldPrice: BN;
 
 	if (useSpread && market.amm.baseSpread > 0) {
 		if (isVariant(direction, 'long')) {
-			oldPrice = calculateAskPrice(market);
+			oldPrice = calculateAskPrice(market, oraclePriceData);
 		} else {
-			oldPrice = calculateBidPrice(market);
+			oldPrice = calculateBidPrice(market, oraclePriceData);
 		}
 	} else {
-		oldPrice = calculateMarkPrice(market);
+		oldPrice = calculateMarkPrice(market, oraclePriceData);
 	}
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO, oldPrice, oldPrice];
@@ -80,26 +83,33 @@ export function calculateTradeSlippage(
 		amount,
 		market,
 		inputAssetType,
+		oraclePriceData,
 		useSpread
 	);
 
-	const entryPrice = calculatePrice(
-		acquiredBase,
-		acquiredQuote,
-		market.amm.pegMultiplier
-	).mul(new BN(-1));
+	const swapDirection = isVariant(direction, 'long')
+		? SwapDirection.REMOVE
+		: SwapDirection.ADD;
+	const quoteAssetAmountAcquired = calculateQuoteAssetAmountSwapped(
+		acquiredQuote.abs(),
+		market.amm.pegMultiplier,
+		swapDirection
+	);
+
+	const entryPrice = quoteAssetAmountAcquired
+		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.mul(MARK_PRICE_PRECISION)
+		.div(acquiredBase.abs());
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 	if (useSpread && market.amm.baseSpread > 0) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			direction
-		);
+		const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+			calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
 		amm = {
 			baseAssetReserve,
 			quoteAssetReserve,
-			sqrtK: market.amm.sqrtK,
-			pegMultiplier: market.amm.pegMultiplier,
+			sqrtK: sqrtK,
+			pegMultiplier: newPeg,
 		};
 	} else {
 		amm = market.amm;
@@ -112,9 +122,9 @@ export function calculateTradeSlippage(
 	);
 
 	if (direction == PositionDirection.SHORT) {
-		assert(newPrice.lt(oldPrice));
+		assert(newPrice.lte(oldPrice));
 	} else {
-		assert(oldPrice.lt(newPrice));
+		assert(oldPrice.lte(newPrice));
 	}
 
 	const pctMaxSlippage = newPrice
@@ -145,8 +155,9 @@ export function calculateTradeSlippage(
 export function calculateTradeAcquiredAmounts(
 	direction: PositionDirection,
 	amount: BN,
-	market: Market,
+	market: MarketAccount,
 	inputAssetType: AssetType = 'quote',
+	oraclePriceData: OraclePriceData,
 	useSpread = true
 ): [BN, BN] {
 	if (amount.eq(ZERO)) {
@@ -157,15 +168,13 @@ export function calculateTradeAcquiredAmounts(
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 	if (useSpread && market.amm.baseSpread > 0) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			direction
-		);
+		const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+			calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
 		amm = {
 			baseAssetReserve,
 			quoteAssetReserve,
-			sqrtK: market.amm.sqrtK,
-			pegMultiplier: market.amm.pegMultiplier,
+			sqrtK: sqrtK,
+			pegMultiplier: newPeg,
 		};
 	} else {
 		amm = market.amm;
@@ -197,19 +206,20 @@ export function calculateTradeAcquiredAmounts(
  * ]
  */
 export function calculateTargetPriceTrade(
-	market: Market,
+	market: MarketAccount,
 	targetPrice: BN,
 	pct: BN = MAXPCT,
 	outputAssetType: AssetType = 'quote',
+	oraclePriceData?: OraclePriceData,
 	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);
+	const markPriceBefore = calculateMarkPrice(market, oraclePriceData);
+	const bidPriceBefore = calculateBidPrice(market, oraclePriceData);
+	const askPriceBefore = calculateAskPrice(market, oraclePriceData);
 
 	let direction;
 	if (targetPrice.gt(markPriceBefore)) {
@@ -230,19 +240,19 @@ export function calculateTargetPriceTrade(
 	let baseAssetReserveBefore: BN;
 	let quoteAssetReserveBefore: BN;
 
+	let peg = market.amm.pegMultiplier;
+
 	if (useSpread && market.amm.baseSpread > 0) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			direction
-		);
+		const { baseAssetReserve, quoteAssetReserve, newPeg } =
+			calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
 		baseAssetReserveBefore = baseAssetReserve;
 		quoteAssetReserveBefore = quoteAssetReserve;
+		peg = newPeg;
 	} 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);
 

package/src/math/utils.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareRootBN = void 0;
+const __1 = require("../");
+const squareRootBN = (n, closeness = new __1.BN(1)) => {
+    // Assuming the sqrt of n as n only
+    let x = n;
+    // The closed guess will be stored in the root
+    let root;
+    // To count the number of iterations
+    let count = 0;
+    const TWO = new __1.BN(2);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    while (count < Number.MAX_SAFE_INTEGER) {
+        count++;
+        // Calculate more closed x
+        root = x.add(n.div(x)).div(TWO);
+        // Check for closeness
+        if (x.sub(root).abs().lte(closeness))
+            break;
+        // Update root
+        x = root;
+    }
+    return root;
+};
+exports.squareRootBN = squareRootBN;
+//# sourceMappingURL=utils.js.map

package/src/math/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":";;;AAAA,2BAAyB;AAElB,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,EAAE,EAAE;IACxD,mCAAmC;IACnC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEV,8CAA8C;IAC9C,IAAI,IAAI,CAAC;IAET,oCAAoC;IACpC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,MAAM,GAAG,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,CAAC;IAEtB,6DAA6D;IAC7D,OAAO,KAAK,GAAG,MAAM,CAAC,gBAAgB,EAAE;QACvC,KAAK,EAAE,CAAC;QAER,0BAA0B;QAC1B,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEhC,sBAAsB;QACtB,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,MAAM;QAE5C,cAAc;QACd,CAAC,GAAG,IAAI,CAAC;KACT;IAED,OAAO,IAAI,CAAC;AACb,CAAC,CAAC;AA1BW,QAAA,YAAY,gBA0BvB"}

package/src/oracles/oracleClientCache.ts

@@ -0,0 +1,20 @@
+import { OracleClient } from './types';
+import { OracleSource } from '../types';
+import { getOracleClient } from '../factory/oracleClient';
+import { Connection } from '@solana/web3.js';
+
+export class OracleClientCache {
+	cache = new Map<string, OracleClient>();
+	public constructor() {}
+
+	public get(oracleSource: OracleSource, connection: Connection) {
+		const key = Object.keys(oracleSource)[0];
+		if (this.cache.has(key)) {
+			return this.cache.get(key);
+		}
+
+		const client = getOracleClient(oracleSource, connection);
+		this.cache.set(key, client);
+		return client;
+	}
+}

package/src/oracles/pythClient.ts

@@ -1,21 +1,16 @@
-import { parsePriceData, PriceData } from '@pythnetwork/client';
+import { parsePriceData } from '@pythnetwork/client';
 import { Connection, PublicKey } from '@solana/web3.js';
-import { OraclePriceData } from './types';
+import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
 import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
 
-export class PythClient {
+export class PythClient implements OracleClient {
 	private connection: Connection;
 
 	public constructor(connection: Connection) {
 		this.connection = connection;
 	}
 
-	public async getPriceData(pricePublicKey: PublicKey): Promise<PriceData> {
-		const account = await this.connection.getAccountInfo(pricePublicKey);
-		return parsePriceData(account.data);
-	}
-
 	public async getOraclePriceData(
 		pricePublicKey: PublicKey
 	): Promise<OraclePriceData> {
@@ -23,9 +18,7 @@ export class PythClient {
 		return this.getOraclePriceDataFromBuffer(accountInfo.data);
 	}
 
-	public async getOraclePriceDataFromBuffer(
-		buffer: Buffer
-	): Promise<OraclePriceData> {
+	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
 		const priceData = parsePriceData(buffer);
 		return {
 			price: convertPythPrice(priceData.aggregate.price, priceData.exponent),

package/src/oracles/quoteAssetOracleClient.ts

@@ -0,0 +1,25 @@
+import { PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BN } from '@project-serum/anchor';
+import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
+
+export const QUOTE_ORACLE_PRICE_DATA: OraclePriceData = {
+	price: MARK_PRICE_PRECISION,
+	slot: new BN(0),
+	confidence: new BN(1),
+	hasSufficientNumberOfDataPoints: true,
+};
+
+export class QuoteAssetOracleClient implements OracleClient {
+	public constructor() {}
+
+	public async getOraclePriceData(
+		_pricePublicKey: PublicKey
+	): Promise<OraclePriceData> {
+		return Promise.resolve(QUOTE_ORACLE_PRICE_DATA);
+	}
+
+	public getOraclePriceDataFromBuffer(_buffer: Buffer): OraclePriceData {
+		return QUOTE_ORACLE_PRICE_DATA;
+	}
+}

package/src/oracles/switchboardClient.ts

@@ -1,25 +1,18 @@
-import {
-	getSwitchboardPid,
-	SwitchboardDecimal,
-} from '@switchboard-xyz/switchboard-v2';
+import { SwitchboardDecimal } from '@switchboard-xyz/switchboard-v2';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
-import { DriftEnv } from '../config';
 import { BN, Program, Idl, AnchorProvider } from '@project-serum/anchor';
 import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
 import { OracleClient, OraclePriceData } from './types';
 import { Wallet } from '../wallet';
 import switchboardV2Idl from '../idl/switchboard_v2.json';
 
-// cache switchboard program for every client object since itll always be the same
-const programMap = new Map<string, Program>();
+let program: Program | undefined;
 
 export class SwitchboardClient implements OracleClient {
 	connection: Connection;
-	env: DriftEnv;
 
-	public constructor(connection: Connection, env: DriftEnv) {
+	public constructor(connection: Connection) {
 		this.connection = connection;
-		this.env = env;
 	}
 
 	public async getOraclePriceData(
@@ -29,10 +22,8 @@ export class SwitchboardClient implements OracleClient {
 		return this.getOraclePriceDataFromBuffer(accountInfo.data);
 	}
 
-	public async getOraclePriceDataFromBuffer(
-		buffer: Buffer
-	): Promise<OraclePriceData> {
-		const program = await this.getProgram();
+	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
+		const program = this.getProgram();
 
 		const aggregatorAccountData =
 			program.account.aggregatorAccountData.coder.accounts.decode(
@@ -61,23 +52,19 @@ export class SwitchboardClient implements OracleClient {
 		};
 	}
 
-	public async getProgram(): Promise<Program> {
-		if (programMap.has(this.env)) {
-			return programMap.get(this.env);
+	public getProgram(): Program {
+		if (program) {
+			return program;
 		}
 
-		const program = await getSwitchboardProgram(this.env, this.connection);
-		programMap.set(this.env, program);
+		program = getSwitchboardProgram(this.connection);
 		return program;
 	}
 }
 
-async function getSwitchboardProgram(
-	env: DriftEnv,
-	connection: Connection
-): Promise<Program> {
+function getSwitchboardProgram(connection: Connection): Program {
 	const DEFAULT_KEYPAIR = Keypair.fromSeed(new Uint8Array(32).fill(1));
-	const programId = getSwitchboardPid(env);
+	const programId = PublicKey.default;
 	const wallet = new Wallet(DEFAULT_KEYPAIR);
 	const provider = new AnchorProvider(connection, wallet, {});
 

package/src/oracles/types.ts

@@ -1,5 +1,6 @@
 import { BN } from '@project-serum/anchor';
 import { PublicKey } from '@solana/web3.js';
+import { OracleSource } from '../types';
 
 export type OraclePriceData = {
 	price: BN;
@@ -10,7 +11,12 @@ export type OraclePriceData = {
 	twapConfidence?: BN;
 };
 
+export type OracleInfo = {
+	publicKey: PublicKey;
+	source: OracleSource;
+};
+
 export interface OracleClient {
-	getOraclePriceDataFromBuffer(buffer: Buffer): Promise<OraclePriceData>;
+	getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
 	getOraclePriceData(publicKey: PublicKey): Promise<OraclePriceData>;
 }

package/src/orders.ts

@@ -1,6 +1,6 @@
 import {
 	isVariant,
-	Market,
+	MarketAccount,
 	Order,
 	PositionDirection,
 	SwapDirection,
@@ -14,6 +14,7 @@ import {
 	calculateSpreadReserves,
 	ClearingHouseUser,
 	isOrderRiskIncreasingInSameDirection,
+	standardizeBaseAssetAmount,
 	TEN_THOUSAND,
 } from '.';
 import {
@@ -36,9 +37,9 @@ import { OraclePriceData } from '.';
 export function calculateNewStateAfterOrder(
 	userAccount: UserAccount,
 	userPosition: UserPosition,
-	market: Market,
+	market: MarketAccount,
 	order: Order
-): [UserAccount, UserPosition, Market] | null {
+): [UserAccount, UserPosition, MarketAccount] | null {
 	if (isVariant(order.status, 'init')) {
 		return null;
 	}
@@ -47,7 +48,7 @@ export function calculateNewStateAfterOrder(
 		market,
 		order
 	);
-	if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
+	if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
 		return null;
 	}
 
@@ -155,8 +156,8 @@ export function calculateNewStateAfterOrder(
 }
 
 function calculateAmountSwapped(
-	marketBefore: Market,
-	marketAfter: Market
+	marketBefore: MarketAccount,
+	marketAfter: MarketAccount
 ): { quoteAssetAmountSwapped: BN; baseAssetAmountSwapped: BN } {
 	return {
 		quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
@@ -172,7 +173,7 @@ function calculateAmountSwapped(
 }
 
 export function calculateBaseAssetAmountMarketCanExecute(
-	market: Market,
+	market: MarketAccount,
 	order: Order,
 	oraclePriceData?: OraclePriceData
 ): BN {
@@ -189,7 +190,7 @@ export function calculateBaseAssetAmountMarketCanExecute(
 }
 
 export function calculateAmountToTradeForLimit(
-	market: Market,
+	market: MarketAccount,
 	order: Order,
 	oraclePriceData?: OraclePriceData
 ): BN {
@@ -213,8 +214,12 @@ export function calculateAmountToTradeForLimit(
 	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
 		market.amm,
 		limitPrice,
-		order.direction,
-		!order.postOnly
+		order.direction
+	);
+
+	const baseAssetAmount = standardizeBaseAssetAmount(
+		maxAmountToTrade,
+		market.amm.baseAssetAmountStepSize
 	);
 
 	// Check that directions are the same
@@ -223,13 +228,13 @@ export function calculateAmountToTradeForLimit(
 		return ZERO;
 	}
 
-	return maxAmountToTrade.gt(order.baseAssetAmount)
+	return baseAssetAmount.gt(order.baseAssetAmount)
 		? order.baseAssetAmount
-		: maxAmountToTrade;
+		: baseAssetAmount;
 }
 
 export function calculateAmountToTradeForTriggerLimit(
-	market: Market,
+	market: MarketAccount,
 	order: Order
 ): BN {
 	if (order.baseAssetAmountFilled.eq(ZERO)) {
@@ -256,7 +261,7 @@ function isSameDirection(
 }
 
 function calculateAmountToTradeForTriggerMarket(
-	market: Market,
+	market: MarketAccount,
 	order: Order
 ): BN {
 	return isTriggerConditionSatisfied(market, order)
@@ -264,8 +269,12 @@ function calculateAmountToTradeForTriggerMarket(
 		: ZERO;
 }
 
-function isTriggerConditionSatisfied(market: Market, order: Order): boolean {
-	const markPrice = calculateMarkPrice(market);
+function isTriggerConditionSatisfied(
+	market: MarketAccount,
+	order: Order,
+	oraclePriceData?: OraclePriceData
+): boolean {
+	const markPrice = calculateMarkPrice(market, oraclePriceData);
 	if (isVariant(order.triggerCondition, 'above')) {
 		return markPrice.gt(order.triggerPrice);
 	} else {
@@ -274,9 +283,10 @@ function isTriggerConditionSatisfied(market: Market, order: Order): boolean {
 }
 
 export function calculateBaseAssetAmountUserCanExecute(
-	market: Market,
+	market: MarketAccount,
 	order: Order,
-	user: ClearingHouseUser
+	user: ClearingHouseUser,
+	oraclePriceData?: OraclePriceData
 ): BN {
 	const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
 	const freeCollateral = user.getFreeCollateral();
@@ -287,7 +297,11 @@ export function calculateBaseAssetAmountUserCanExecute(
 		const position =
 			user.getUserPosition(order.marketIndex) ||
 			user.getEmptyPosition(order.marketIndex);
-		const positionValue = calculateBaseAssetValue(market, position);
+		const positionValue = calculateBaseAssetValue(
+			market,
+			position,
+			oraclePriceData
+		);
 		quoteAssetAmount = freeCollateral
 			.mul(maxLeverage)
 			.div(TEN_THOUSAND)
@@ -307,7 +321,8 @@ export function calculateBaseAssetAmountUserCanExecute(
 	if (useSpread) {
 		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
 			market.amm,
-			order.direction
+			order.direction,
+			oraclePriceData
 		);
 		amm = {
 			baseAssetReserve,

package/src/slot/SlotSubscriber.ts

@@ -0,0 +1,32 @@
+import { Connection } from '@solana/web3.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type SlotSubscriberConfig = {}; // for future customization
+
+export class SlotSubscriber {
+	currentSlot: number;
+	subscriptionId: number;
+
+	public constructor(
+		private connection: Connection,
+		_config?: SlotSubscriberConfig
+	) {}
+
+	public async subscribe(): Promise<void> {
+		this.currentSlot = await this.connection.getSlot('confirmed');
+
+		this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
+			this.currentSlot = slotInfo.slot;
+		});
+	}
+
+	public getSlot(): number {
+		return this.currentSlot;
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.subscriptionId) {
+			await this.connection.removeSlotChangeListener(this.subscriptionId);
+		}
+	}
+}

package/src/tx/retryTxSender.ts

@@ -1,4 +1,4 @@
-import { TxSender } from './types';
+import { TxSender, TxSigAndSlot } from './types';
 import {
 	Commitment,
 	ConfirmOptions,
@@ -43,7 +43,7 @@ export class RetryTxSender implements TxSender {
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,
 		opts?: ConfirmOptions
-	): Promise<TransactionSignature> {
+	): Promise<TxSigAndSlot> {
 		if (additionalSigners === undefined) {
 			additionalSigners = [];
 		}
@@ -86,8 +86,10 @@ export class RetryTxSender implements TxSender {
 			}
 		})();
 
+		let slot: number;
 		try {
-			await this.confirmTransaction(txid, opts.commitment);
+			const result = await this.confirmTransaction(txid, opts.commitment);
+			slot = result.context.slot;
 		} catch (e) {
 			console.error(e);
 			throw e;
@@ -95,7 +97,7 @@ export class RetryTxSender implements TxSender {
 			stopWaiting();
 		}
 
-		return txid;
+		return { txSig: txid, slot };
 	}
 
 	async prepareTx(

package/src/tx/types.ts

@@ -6,6 +6,11 @@ import {
 	TransactionSignature,
 } from '@solana/web3.js';
 
+export type TxSigAndSlot = {
+	txSig: TransactionSignature;
+	slot: number;
+};
+
 export interface TxSender {
 	provider: Provider;
 
@@ -13,5 +18,5 @@ export interface TxSender {
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,
 		opts?: ConfirmOptions
-	): Promise<TransactionSignature>;
+	): Promise<TxSigAndSlot>;
 }

package/src/tx/utils.ts

@@ -1,5 +1,24 @@
-import { Transaction, TransactionInstruction } from '@solana/web3.js';
+import {
+	Transaction,
+	TransactionInstruction,
+	ComputeBudgetProgram,
+} from '@solana/web3.js';
 
-export function wrapInTx(instruction: TransactionInstruction): Transaction {
-	return new Transaction().add(instruction);
+const COMPUTE_UNITS_DEFAULT = 200_000;
+
+export function wrapInTx(
+	instruction: TransactionInstruction,
+	computeUnits = 500_000 // TODO, requires less code change
+): Transaction {
+	const tx = new Transaction();
+	if (computeUnits != COMPUTE_UNITS_DEFAULT) {
+		tx.add(
+			ComputeBudgetProgram.requestUnits({
+				units: computeUnits,
+				additionalFee: 0,
+			})
+		);
+	}
+
+	return tx.add(instruction);
 }