@drift-labs/sdk 0.2.0-temp.0 → 0.2.0-temp.1

package/src/{mockUSDCFaucet.ts → tokenFaucet.ts}

@@ -3,7 +3,6 @@ import { AnchorProvider, Idl, Program } from '@project-serum/anchor';
 import {
 	AccountInfo,
 	ASSOCIATED_TOKEN_PROGRAM_ID,
-	MintLayout,
 	Token,
 	TOKEN_PROGRAM_ID,
 } from '@solana/spl-token';
@@ -11,27 +10,28 @@ import {
 	ConfirmOptions,
 	Connection,
 	PublicKey,
-	SystemProgram,
 	SYSVAR_RENT_PUBKEY,
 	Transaction,
 	TransactionInstruction,
 	TransactionSignature,
 } from '@solana/web3.js';
 import { BN } from '.';
-import mockUSDCFaucetIDL from './idl/mock_usdc_faucet.json';
+import tokenFaucet from './idl/token_faucet.json';
 import { IWallet } from './types';
 
-export class MockUSDCFaucet {
+export class TokenFaucet {
 	connection: Connection;
 	wallet: IWallet;
 	public program: Program;
 	provider: AnchorProvider;
+	mint: PublicKey;
 	opts?: ConfirmOptions;
 
 	public constructor(
 		connection: Connection,
 		wallet: IWallet,
 		programId: PublicKey,
+		mint: PublicKey,
 		opts?: ConfirmOptions
 	) {
 		this.connection = connection;
@@ -39,78 +39,56 @@ export class MockUSDCFaucet {
 		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);
+		this.program = new Program(tokenFaucet as Idl, programId, provider);
+		this.mint = mint;
 	}
 
-	public async getMockUSDCFaucetStatePublicKeyAndNonce(): Promise<
+	public async getFaucetConfigPublicKeyAndNonce(): Promise<
 		[PublicKey, number]
 	> {
 		return anchor.web3.PublicKey.findProgramAddress(
-			[Buffer.from(anchor.utils.bytes.utf8.encode('mock_usdc_faucet'))],
+			[
+				Buffer.from(anchor.utils.bytes.utf8.encode('faucet_config')),
+				this.mint.toBuffer(),
+			],
 			this.program.programId
 		);
 	}
 
-	mockUSDCFaucetStatePublicKey?: PublicKey;
-	public async getMockUSDCFaucetStatePublicKey(): Promise<PublicKey> {
-		if (this.mockUSDCFaucetStatePublicKey) {
-			return this.mockUSDCFaucetStatePublicKey;
-		}
-		this.mockUSDCFaucetStatePublicKey = (
-			await this.getMockUSDCFaucetStatePublicKeyAndNonce()
+	public async getMintAuthority(): Promise<PublicKey> {
+		return (
+			await anchor.web3.PublicKey.findProgramAddress(
+				[
+					Buffer.from(anchor.utils.bytes.utf8.encode('mint_authority')),
+					this.mint.toBuffer(),
+				],
+				this.program.programId
+			)
 		)[0];
-		return this.mockUSDCFaucetStatePublicKey;
 	}
 
-	public async initialize(): Promise<TransactionSignature> {
-		const stateAccountRPCResponse = await this.connection.getParsedAccountInfo(
-			await this.getMockUSDCFaucetStatePublicKey()
-		);
-		if (stateAccountRPCResponse.value !== null) {
-			throw new Error('Faucet already initialized');
-		}
-
-		const fakeUSDCMint = anchor.web3.Keypair.generate();
-		const createUSDCMintAccountIx = SystemProgram.createAccount({
-			fromPubkey: this.wallet.publicKey,
-			newAccountPubkey: fakeUSDCMint.publicKey,
-			lamports: await Token.getMinBalanceRentForExemptMint(this.connection),
-			space: MintLayout.span,
-			programId: TOKEN_PROGRAM_ID,
-		});
-
-		const [mintAuthority, _mintAuthorityNonce] =
-			await PublicKey.findProgramAddress(
-				[fakeUSDCMint.publicKey.toBuffer()],
-				this.program.programId
-			);
-
-		const initUSDCMintIx = Token.createInitMintInstruction(
-			TOKEN_PROGRAM_ID,
-			fakeUSDCMint.publicKey,
-			6,
-			mintAuthority,
-			null
-		);
+	public async getFaucetConfigPublicKey(): Promise<PublicKey> {
+		return (await this.getFaucetConfigPublicKeyAndNonce())[0];
+	}
 
-		const [mockUSDCFaucetStatePublicKey, mockUSDCFaucetStateNonce] =
-			await this.getMockUSDCFaucetStatePublicKeyAndNonce();
-		return await this.program.rpc.initialize(mockUSDCFaucetStateNonce, {
+	public async initialize(): Promise<TransactionSignature> {
+		const [faucetConfigPublicKey] =
+			await this.getFaucetConfigPublicKeyAndNonce();
+		return await this.program.rpc.initialize({
 			accounts: {
-				mockUsdcFaucetState: mockUSDCFaucetStatePublicKey,
+				faucetConfig: faucetConfigPublicKey,
 				admin: this.wallet.publicKey,
-				mintAccount: fakeUSDCMint.publicKey,
+				mintAccount: this.mint,
 				rent: SYSVAR_RENT_PUBKEY,
 				systemProgram: anchor.web3.SystemProgram.programId,
+				tokenProgram: TOKEN_PROGRAM_ID,
 			},
-			instructions: [createUSDCMintAccountIx, initUSDCMintIx],
-			signers: [fakeUSDCMint],
 		});
 	}
 
 	public async fetchState(): Promise<any> {
-		return await this.program.account.mockUsdcFaucetState.fetch(
-			await this.getMockUSDCFaucetStatePublicKey()
+		return await this.program.account.faucetConfig.fetch(
+			await this.getFaucetConfigPublicKey()
 		);
 	}
 
@@ -118,18 +96,29 @@ export class MockUSDCFaucet {
 		userTokenAccount: PublicKey,
 		amount: BN
 	): Promise<TransactionSignature> {
-		const state: any = await this.fetchState();
 		return await this.program.rpc.mintToUser(amount, {
 			accounts: {
-				mockUsdcFaucetState: await this.getMockUSDCFaucetStatePublicKey(),
-				mintAccount: state.mint,
+				faucetConfig: await this.getFaucetConfigPublicKey(),
+				mintAccount: this.mint,
 				userTokenAccount,
-				mintAuthority: state.mintAuthority,
+				mintAuthority: await this.getMintAuthority(),
 				tokenProgram: TOKEN_PROGRAM_ID,
 			},
 		});
 	}
 
+	public async transferMintAuthority(): Promise<TransactionSignature> {
+		return await this.program.rpc.transferMintAuthority({
+			accounts: {
+				faucetConfig: await this.getFaucetConfigPublicKey(),
+				mintAccount: this.mint,
+				mintAuthority: await this.getMintAuthority(),
+				tokenProgram: TOKEN_PROGRAM_ID,
+				admin: this.wallet.publicKey,
+			},
+		});
+	}
+
 	public async createAssociatedTokenAccountAndMintTo(
 		userPublicKey: PublicKey,
 		amount: BN
@@ -166,7 +155,7 @@ export class MockUSDCFaucet {
 
 		const mintToIx = await this.program.instruction.mintToUser(amount, {
 			accounts: {
-				mockUsdcFaucetState: await this.getMockUSDCFaucetStatePublicKey(),
+				faucetConfig: await this.getFaucetConfigPublicKey(),
 				mintAccount: state.mint,
 				userTokenAccount: associateTokenPublicKey,
 				mintAuthority: state.mintAuthority,

package/src/tx/types.js

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

package/src/tx/utils.js

@@ -0,0 +1,17 @@
+"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/tx/utils.ts

@@ -8,7 +8,7 @@ const COMPUTE_UNITS_DEFAULT = 200_000;
 
 export function wrapInTx(
 	instruction: TransactionInstruction,
-	computeUnits = 500_000 // TODO, requires less code change
+	computeUnits = 600_000 // TODO, requires less code change
 ): Transaction {
 	const tx = new Transaction();
 	if (computeUnits != COMPUTE_UNITS_DEFAULT) {

package/src/types.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultOrderParams = exports.LiquidationType = exports.TradeSide = exports.isOneOfVariant = exports.isVariant = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.DepositDirection = exports.PositionDirection = exports.BankBalanceType = exports.SwapDirection = void 0;
+const _1 = require(".");
+// # Utility Types / Enums / Constants
+class SwapDirection {
+}
+exports.SwapDirection = SwapDirection;
+SwapDirection.ADD = { add: {} };
+SwapDirection.REMOVE = { remove: {} };
+class BankBalanceType {
+}
+exports.BankBalanceType = BankBalanceType;
+BankBalanceType.DEPOSIT = { deposit: {} };
+BankBalanceType.BORROW = { borrow: {} };
+class PositionDirection {
+}
+exports.PositionDirection = PositionDirection;
+PositionDirection.LONG = { long: {} };
+PositionDirection.SHORT = { short: {} };
+class DepositDirection {
+}
+exports.DepositDirection = DepositDirection;
+DepositDirection.DEPOSIT = { deposit: {} };
+DepositDirection.WITHDRAW = { withdraw: {} };
+class OracleSource {
+}
+exports.OracleSource = OracleSource;
+OracleSource.PYTH = { pyth: {} };
+OracleSource.SWITCHBOARD = { switchboard: {} };
+OracleSource.QUOTE_ASSET = { quoteAsset: {} };
+class OrderType {
+}
+exports.OrderType = OrderType;
+OrderType.LIMIT = { limit: {} };
+OrderType.TRIGGER_MARKET = { triggerMarket: {} };
+OrderType.TRIGGER_LIMIT = { triggerLimit: {} };
+OrderType.MARKET = { market: {} };
+class OrderStatus {
+}
+exports.OrderStatus = OrderStatus;
+OrderStatus.INIT = { init: {} };
+OrderStatus.OPEN = { open: {} };
+class OrderDiscountTier {
+}
+exports.OrderDiscountTier = OrderDiscountTier;
+OrderDiscountTier.NONE = { none: {} };
+OrderDiscountTier.FIRST = { first: {} };
+OrderDiscountTier.SECOND = { second: {} };
+OrderDiscountTier.THIRD = { third: {} };
+OrderDiscountTier.FOURTH = { fourth: {} };
+class OrderAction {
+}
+exports.OrderAction = OrderAction;
+OrderAction.PLACE = { place: {} };
+OrderAction.CANCEL = { cancel: {} };
+OrderAction.EXPIRE = { expire: {} };
+OrderAction.FILL = { fill: {} };
+OrderAction.TRIGGER = { trigger: {} };
+class OrderActionExplanation {
+}
+exports.OrderActionExplanation = OrderActionExplanation;
+OrderActionExplanation.NONE = { none: {} };
+OrderActionExplanation.BREACHED_MARGIN_REQUIREMENT = {
+    breachedMarginRequirement: {},
+};
+OrderActionExplanation.ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
+    oraclePriceBreachedLimitPrice: {},
+};
+OrderActionExplanation.MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
+    marketOrderFilledToLimitPrice: {},
+};
+class OrderTriggerCondition {
+}
+exports.OrderTriggerCondition = OrderTriggerCondition;
+OrderTriggerCondition.ABOVE = { above: {} };
+OrderTriggerCondition.BELOW = { below: {} };
+function isVariant(object, type) {
+    return object.hasOwnProperty(type);
+}
+exports.isVariant = isVariant;
+function isOneOfVariant(object, types) {
+    return types.reduce((result, type) => {
+        return result || object.hasOwnProperty(type);
+    }, false);
+}
+exports.isOneOfVariant = isOneOfVariant;
+var TradeSide;
+(function (TradeSide) {
+    TradeSide[TradeSide["None"] = 0] = "None";
+    TradeSide[TradeSide["Buy"] = 1] = "Buy";
+    TradeSide[TradeSide["Sell"] = 2] = "Sell";
+})(TradeSide = exports.TradeSide || (exports.TradeSide = {}));
+class LiquidationType {
+}
+exports.LiquidationType = LiquidationType;
+LiquidationType.LIQUIDATE_PERP = { liquidatePerp: {} };
+LiquidationType.LIQUIDATE_BORROW = { liquidateBorrow: {} };
+LiquidationType.LIQUIDATE_BORROW_FOR_PERP_PNL = {
+    liquidateBorrowForPerpPnl: {},
+};
+LiquidationType.LIQUIDATE_PERP_PNL_FOR_DEPOSIT = {
+    liquidatePerpPnlForDeposit: {},
+};
+exports.DefaultOrderParams = {
+    orderType: OrderType.MARKET,
+    userOrderId: 0,
+    direction: PositionDirection.LONG,
+    baseAssetAmount: _1.ZERO,
+    price: _1.ZERO,
+    marketIndex: _1.ZERO,
+    reduceOnly: false,
+    postOnly: false,
+    immediateOrCancel: false,
+    triggerPrice: _1.ZERO,
+    triggerCondition: OrderTriggerCondition.ABOVE,
+    positionLimit: _1.ZERO,
+    oraclePriceOffset: _1.ZERO,
+    padding0: _1.ZERO,
+    padding1: _1.ZERO,
+    optionalAccounts: {
+        discountToken: false,
+        referrer: false,
+    },
+};

package/src/types.ts

@@ -1,5 +1,5 @@
 import { PublicKey, Transaction } from '@solana/web3.js';
-import { BN } from '.';
+import { BN, ZERO } from '.';
 
 // # Utility Types / Enums / Constants
 export class SwapDirection {
@@ -17,6 +17,11 @@ export class PositionDirection {
 	static readonly SHORT = { short: {} };
 }
 
+export class DepositDirection {
+	static readonly DEPOSIT = { deposit: {} };
+	static readonly WITHDRAW = { withdraw: {} };
+}
+
 export class OracleSource {
 	static readonly PYTH = { pyth: {} };
 	static readonly SWITCHBOARD = { switchboard: {} };
@@ -51,6 +56,19 @@ export class OrderAction {
 	static readonly TRIGGER = { trigger: {} };
 }
 
+export class OrderActionExplanation {
+	static readonly NONE = { none: {} };
+	static readonly BREACHED_MARGIN_REQUIREMENT = {
+		breachedMarginRequirement: {},
+	};
+	static readonly ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
+		oraclePriceBreachedLimitPrice: {},
+	};
+	static readonly MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
+		marketOrderFilledToLimitPrice: {},
+	};
+}
+
 export class OrderTriggerCondition {
 	static readonly ABOVE = { above: {} };
 	static readonly BELOW = { below: {} };
@@ -92,6 +110,7 @@ export type DepositRecord = {
 	};
 	bankIndex: BN;
 	amount: BN;
+	oraclePrice: BN;
 	from?: PublicKey;
 	to?: PublicKey;
 };
@@ -142,20 +161,67 @@ export type FundingPaymentRecord = {
 
 export type LiquidationRecord = {
 	ts: BN;
-	recordId: BN;
-	userAuthority: PublicKey;
 	user: PublicKey;
-	partial: boolean;
-	baseAssetValue: BN;
-	baseAssetValueClosed: BN;
-	liquidationFee: BN;
-	feeToLiquidator: BN;
-	feeToInsuranceFund: BN;
 	liquidator: PublicKey;
+	liquidationType: LiquidationType;
+	marginRequirement: BN;
 	totalCollateral: BN;
-	collateral: BN;
-	unrealizedPnl: BN;
-	marginRatio: BN;
+	liquidatePerp: LiquidatePerpRecord;
+	liquidateBorrow: LiquidateBorrowRecord;
+	liquidateBorrowForPerpPnl: LiquidateBorrowForPerpPnlRecord;
+	liquidatePerpPnlForDeposit: LiquidatePerpPnlForDepositRecord;
+};
+
+export class LiquidationType {
+	static readonly LIQUIDATE_PERP = { liquidatePerp: {} };
+	static readonly LIQUIDATE_BORROW = { liquidateBorrow: {} };
+	static readonly LIQUIDATE_BORROW_FOR_PERP_PNL = {
+		liquidateBorrowForPerpPnl: {},
+	};
+	static readonly LIQUIDATE_PERP_PNL_FOR_DEPOSIT = {
+		liquidatePerpPnlForDeposit: {},
+	};
+}
+
+export type LiquidatePerpRecord = {
+	marketIndex: BN;
+	orderIds: BN[];
+	oraclePrice: BN;
+	baseAssetAmount: BN;
+	quoteAssetAmount: BN;
+	userPnl: BN;
+	liquidatorPnl: BN;
+	canceledOrdersFee: BN;
+	userOrderId: BN;
+	liquidatorOrderId: BN;
+	fillRecordId: BN;
+};
+
+export type LiquidateBorrowRecord = {
+	assetBankIndex: BN;
+	assetPrice: BN;
+	assetTransfer: BN;
+	liabilityBankIndex: BN;
+	liabilityPrice: BN;
+	liabilityTransfer: BN;
+};
+
+export type LiquidateBorrowForPerpPnlRecord = {
+	marketIndex: BN;
+	marketOraclePrice: BN;
+	pnlTransfer: BN;
+	liabilityBankIndex: BN;
+	liabilityPrice: BN;
+	liabilityTransfer: BN;
+};
+
+export type LiquidatePerpPnlForDepositRecord = {
+	marketIndex: BN;
+	marketOraclePrice: BN;
+	pnlTransfer: BN;
+	assetBankIndex: BN;
+	assetPrice: BN;
+	assetTransfer: BN;
 };
 
 export type OrderRecord = {
@@ -164,7 +230,10 @@ export type OrderRecord = {
 	maker: PublicKey;
 	takerOrder: Order;
 	makerOrder: Order;
+	takerUnsettledPnl: BN;
+	makerUnsettledPnl: BN;
 	action: OrderAction;
+	actionExplanation: OrderActionExplanation;
 	filler: PublicKey;
 	fillRecordId: BN;
 	marketIndex: BN;
@@ -219,9 +288,9 @@ export type MarketAccount = {
 	openInterest: BN;
 	marginRatioInitial: number;
 	marginRatioMaintenance: number;
-	marginRatioPartial: number;
 	nextFillRecordId: BN;
 	pnlPool: PoolBalance;
+	liquidationFee: BN;
 };
 
 export type BankAccount = {
@@ -245,6 +314,7 @@ export type BankAccount = {
 	maintenanceAssetWeight: BN;
 	initialLiabilityWeight: BN;
 	maintenanceLiabilityWeight: BN;
+	liquidationFee: BN;
 };
 
 export type PoolBalance = {
@@ -261,6 +331,8 @@ export type AMM = {
 	lastMarkPriceTwapTs: BN;
 	lastOraclePriceTwap: BN;
 	lastOraclePriceTwapTs: BN;
+	lastOracleMarkSpreadPct: BN;
+	lastOracleConfPct: BN;
 	oracle: PublicKey;
 	oracleSource: OracleSource;
 	fundingPeriod: BN;
@@ -275,6 +347,8 @@ export type AMM = {
 	totalFee: BN;
 	minimumQuoteAssetTradeSize: BN;
 	baseAssetAmountStepSize: BN;
+	maxBaseAssetAmountRatio: number;
+	maxSlippageRatio: number;
 	lastOraclePrice: BN;
 	baseSpread: number;
 	curveUpdateIntensity: number;
@@ -323,6 +397,7 @@ export type UserAccount = {
 	};
 	positions: UserPosition[];
 	orders: Order[];
+	beingLiquidated: boolean;
 };
 
 export type UserBankBalance = {
@@ -365,7 +440,6 @@ export type OrderParams = {
 	orderType: OrderType;
 	userOrderId: number;
 	direction: PositionDirection;
-	quoteAssetAmount: BN;
 	baseAssetAmount: BN;
 	price: BN;
 	marketIndex: BN;
@@ -384,11 +458,49 @@ export type OrderParams = {
 	};
 };
 
+export type NecessaryOrderParams = {
+	orderType: OrderType;
+	marketIndex: BN;
+	baseAssetAmount: BN;
+	direction: PositionDirection;
+};
+
+export type OptionalOrderParams = {
+	[Property in keyof OrderParams]?: OrderParams[Property];
+} & NecessaryOrderParams;
+
+export const DefaultOrderParams = {
+	orderType: OrderType.MARKET,
+	userOrderId: 0,
+	direction: PositionDirection.LONG,
+	baseAssetAmount: ZERO,
+	price: ZERO,
+	marketIndex: ZERO,
+	reduceOnly: false,
+	postOnly: false,
+	immediateOrCancel: false,
+	triggerPrice: ZERO,
+	triggerCondition: OrderTriggerCondition.ABOVE,
+	positionLimit: ZERO,
+	oraclePriceOffset: ZERO,
+	padding0: ZERO,
+	padding1: ZERO,
+	optionalAccounts: {
+		discountToken: false,
+		referrer: false,
+	},
+};
+
 export type MakerInfo = {
 	maker: PublicKey;
 	order: Order;
 };
 
+export type TakerInfo = {
+	taker: PublicKey;
+	order: Order;
+};
+
 // # Misc Types
 export interface IWallet {
 	signTransaction(tx: Transaction): Promise<Transaction>;
@@ -430,6 +542,7 @@ export type FeeStructure = {
 	makerRebateNumerator: BN;
 	makerRebateDenominator: BN;
 	fillerRewardStructure: OrderFillerRewardStructure;
+	cancelOrderFee: BN;
 };
 
 export type OracleGuardRails = {
@@ -451,4 +564,4 @@ export type OrderFillerRewardStructure = {
 	timeBasedRewardLowerBound: BN;
 };
 
-export type MarginCategory = 'Initial' | 'Partial' | 'Maintenance';
+export type MarginCategory = 'Initial' | 'Maintenance';

package/src/userName.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeName = exports.encodeName = exports.DEFAULT_USER_NAME = exports.MAX_NAME_LENGTH = void 0;
+exports.MAX_NAME_LENGTH = 32;
+exports.DEFAULT_USER_NAME = 'Main Account';
+function encodeName(name) {
+    if (name.length > exports.MAX_NAME_LENGTH) {
+        throw Error(`User name (${name}) longer than 32 characters`);
+    }
+    const buffer = Buffer.alloc(32);
+    buffer.fill(name);
+    buffer.fill(' ', name.length);
+    return Array(...buffer);
+}
+exports.encodeName = encodeName;
+function decodeName(bytes) {
+    const buffer = Buffer.from(bytes);
+    return buffer.toString('utf8').trim();
+}
+exports.decodeName = decodeName;

package/src/util/computeUnits.js

@@ -1,17 +1,27 @@
 "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;
-async function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
-    const tx = await connection.getTransaction(txSignature, { commitment });
-    const computeUnits = [];
-    const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of 200000 compute units`);
-    tx.meta.logMessages.forEach((logMessage) => {
-        const match = logMessage.match(regex);
-        if (match && match[1]) {
-            computeUnits.push(match[1]);
-        }
+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;
     });
-    return computeUnits;
 }
 exports.findComputeUnitConsumption = findComputeUnitConsumption;
-//# sourceMappingURL=computeUnits.js.map

package/src/util/computeUnits.ts

@@ -9,7 +9,7 @@ export async function findComputeUnitConsumption(
 	const tx = await connection.getTransaction(txSignature, { commitment });
 	const computeUnits = [];
 	const regex = new RegExp(
-		`Program ${programId.toString()} consumed ([0-9]{0,6}) of 200000 compute units`
+		`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);

package/src/util/getTokenAddress.js

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

package/src/util/promiseTimeout.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTimeout = void 0;
+function promiseTimeout(promise, timeoutMs) {
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => resolve(null), timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).then((result) => {
+        clearTimeout(timeoutId);
+        return result;
+    });
+}
+exports.promiseTimeout = promiseTimeout;