@drift-labs/sdk 0.2.0-master.10 → 0.2.0-master.13

package/src/tokenFaucet.js

@@ -0,0 +1,189 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenFaucet = void 0;
+const anchor = __importStar(require("@project-serum/anchor"));
+const anchor_1 = require("@project-serum/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const token_faucet_json_1 = __importDefault(require("./idl/token_faucet.json"));
+class TokenFaucet {
+    constructor(connection, wallet, programId, mint, opts) {
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts || anchor_1.AnchorProvider.defaultOptions();
+        const provider = new anchor_1.AnchorProvider(connection, wallet, this.opts);
+        this.provider = provider;
+        this.program = new anchor_1.Program(token_faucet_json_1.default, programId, provider);
+        this.mint = mint;
+    }
+    getFaucetConfigPublicKeyAndNonce() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return anchor.web3.PublicKey.findProgramAddress([
+                Buffer.from(anchor.utils.bytes.utf8.encode('faucet_config')),
+                this.mint.toBuffer(),
+            ], this.program.programId);
+        });
+    }
+    getMintAuthority() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield anchor.web3.PublicKey.findProgramAddress([
+                Buffer.from(anchor.utils.bytes.utf8.encode('mint_authority')),
+                this.mint.toBuffer(),
+            ], this.program.programId))[0];
+        });
+    }
+    getFaucetConfigPublicKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getFaucetConfigPublicKeyAndNonce())[0];
+        });
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [faucetConfigPublicKey] = yield this.getFaucetConfigPublicKeyAndNonce();
+            return yield this.program.rpc.initialize({
+                accounts: {
+                    faucetConfig: faucetConfigPublicKey,
+                    admin: this.wallet.publicKey,
+                    mintAccount: this.mint,
+                    rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                    systemProgram: anchor.web3.SystemProgram.programId,
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    fetchState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.account.faucetConfig.fetch(yield this.getFaucetConfigPublicKey());
+        });
+    }
+    mintToUserIx(userTokenAccount, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.program.instruction.mintToUser(amount, {
+                accounts: {
+                    faucetConfig: yield this.getFaucetConfigPublicKey(),
+                    mintAccount: this.mint,
+                    userTokenAccount,
+                    mintAuthority: yield this.getMintAuthority(),
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                },
+            });
+        });
+    }
+    mintToUser(userTokenAccount, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mintIx = yield this.mintToUserIx(userTokenAccount, amount);
+            const tx = new web3_js_1.Transaction().add(mintIx);
+            const txSig = yield this.program.provider.sendAndConfirm(tx, [], this.opts);
+            return txSig;
+        });
+    }
+    transferMintAuthority() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.program.rpc.transferMintAuthority({
+                accounts: {
+                    faucetConfig: yield this.getFaucetConfigPublicKey(),
+                    mintAccount: this.mint,
+                    mintAuthority: yield this.getMintAuthority(),
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    admin: this.wallet.publicKey,
+                },
+            });
+        });
+    }
+    createAssociatedTokenAccountAndMintTo(userPublicKey, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tx = new web3_js_1.Transaction();
+            const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] = yield this.createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount);
+            let associatedTokenAccountExists = false;
+            try {
+                const assosciatedTokenAccount = yield this.connection.getAccountInfo(associatedTokenPublicKey);
+                associatedTokenAccountExists = !!assosciatedTokenAccount;
+            }
+            catch (e) {
+                // token account doesn't exist
+                associatedTokenAccountExists = false;
+            }
+            const skipAccountCreation = associatedTokenAccountExists;
+            if (!skipAccountCreation)
+                tx.add(createAssociatedAccountIx);
+            tx.add(mintToTx);
+            const txSig = yield this.program.provider.sendAndConfirm(tx, [], this.opts);
+            return [associatedTokenPublicKey, txSig];
+        });
+    }
+    createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.fetchState();
+            const associateTokenPublicKey = yield this.getAssosciatedMockUSDMintAddress({ userPubKey: userPublicKey });
+            const createAssociatedAccountIx = spl_token_1.Token.createAssociatedTokenAccountInstruction(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.mint, associateTokenPublicKey, userPublicKey, this.wallet.publicKey);
+            const mintToIx = yield this.mintToUserIx(associateTokenPublicKey, amount);
+            return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
+        });
+    }
+    getAssosciatedMockUSDMintAddress(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = yield this.fetchState();
+            return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, state.mint, props.userPubKey);
+        });
+    }
+    getTokenAccountInfo(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const assosciatedKey = yield this.getAssosciatedMockUSDMintAddress(props);
+            const state = yield this.fetchState();
+            const token = new spl_token_1.Token(this.connection, state.mint, spl_token_1.TOKEN_PROGRAM_ID, 
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            this.provider.payer);
+            return yield token.getAccountInfo(assosciatedKey);
+        });
+    }
+    subscribeToTokenAccount(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokenAccountKey = yield this.getAssosciatedMockUSDMintAddress(props);
+                props.callback(yield this.getTokenAccountInfo(props));
+                // Couldn't find a way to do it using anchor framework subscription, someone on serum discord recommended this way
+                this.connection.onAccountChange(tokenAccountKey, (_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */) => __awaiter(this, void 0, void 0, function* () {
+                    props.callback(yield this.getTokenAccountInfo(props));
+                }));
+                return true;
+            }
+            catch (e) {
+                return false;
+            }
+        });
+    }
+}
+exports.TokenFaucet = TokenFaucet;

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,93 +39,92 @@ 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()
 		);
 	}
 
+	private async mintToUserIx(userTokenAccount: PublicKey, amount: BN) {
+		return this.program.instruction.mintToUser(amount, {
+			accounts: {
+				faucetConfig: await this.getFaucetConfigPublicKey(),
+				mintAccount: this.mint,
+				userTokenAccount,
+				mintAuthority: await this.getMintAuthority(),
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+		});
+	}
+
 	public async mintToUser(
 		userTokenAccount: PublicKey,
 		amount: BN
 	): Promise<TransactionSignature> {
-		const state: any = await this.fetchState();
-		return await this.program.rpc.mintToUser(amount, {
+		const mintIx = await this.mintToUserIx(userTokenAccount, amount);
+
+		const tx = new Transaction().add(mintIx);
+
+		const txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async transferMintAuthority(): Promise<TransactionSignature> {
+		return await this.program.rpc.transferMintAuthority({
 			accounts: {
-				mockUsdcFaucetState: await this.getMockUSDCFaucetStatePublicKey(),
-				mintAccount: state.mint,
-				userTokenAccount,
-				mintAuthority: state.mintAuthority,
+				faucetConfig: await this.getFaucetConfigPublicKey(),
+				mintAccount: this.mint,
+				mintAuthority: await this.getMintAuthority(),
 				tokenProgram: TOKEN_PROGRAM_ID,
+				admin: this.wallet.publicKey,
 			},
 		});
 	}
@@ -134,12 +133,33 @@ export class MockUSDCFaucet {
 		userPublicKey: PublicKey,
 		amount: BN
 	): Promise<[PublicKey, TransactionSignature]> {
+		const tx = new Transaction();
+
 		const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] =
 			await this.createAssociatedTokenAccountAndMintToInstructions(
 				userPublicKey,
 				amount
 			);
-		const tx = new Transaction().add(createAssociatedAccountIx).add(mintToTx);
+
+		let associatedTokenAccountExists = false;
+
+		try {
+			const assosciatedTokenAccount = await this.connection.getAccountInfo(
+				associatedTokenPublicKey
+			);
+
+			associatedTokenAccountExists = !!assosciatedTokenAccount;
+		} catch (e) {
+			// token account doesn't exist
+			associatedTokenAccountExists = false;
+		}
+
+		const skipAccountCreation = associatedTokenAccountExists;
+
+		if (!skipAccountCreation) tx.add(createAssociatedAccountIx);
+
+		tx.add(mintToTx);
+
 		const txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
 		return [associatedTokenPublicKey, txSig];
 	}
@@ -164,15 +184,7 @@ export class MockUSDCFaucet {
 				this.wallet.publicKey
 			);
 
-		const mintToIx = await this.program.instruction.mintToUser(amount, {
-			accounts: {
-				mockUsdcFaucetState: await this.getMockUSDCFaucetStatePublicKey(),
-				mintAccount: state.mint,
-				userTokenAccount: associateTokenPublicKey,
-				mintAuthority: state.mintAuthority,
-				tokenProgram: TOKEN_PROGRAM_ID,
-			},
-		});
+		const mintToIx = await this.mintToUserIx(associateTokenPublicKey, amount);
 
 		return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
 	}

package/src/tx/retryTxSender.ts

@@ -56,9 +56,17 @@ export class RetryTxSender implements TxSender {
 		const rawTransaction = tx.serialize();
 		const startTime = this.getTimestamp();
 
-		const txid: TransactionSignature =
-			await this.provider.connection.sendRawTransaction(rawTransaction, opts);
-		this.sendToAdditionalConnections(rawTransaction, opts);
+		let txid: TransactionSignature;
+		try {
+			txid = await this.provider.connection.sendRawTransaction(
+				rawTransaction,
+				opts
+			);
+			this.sendToAdditionalConnections(rawTransaction, opts);
+		} catch (e) {
+			console.error(e);
+			throw e;
+		}
 
 		let done = false;
 		const resolveReference: ResolveReference = {

package/src/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultOrderParams = 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;
+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 {
@@ -91,6 +91,17 @@ var TradeSide;
     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,

package/src/types.ts

@@ -67,6 +67,12 @@ export class OrderActionExplanation {
 	static readonly MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
 		marketOrderFilledToLimitPrice: {},
 	};
+	static readonly CANCELED_FOR_LIQUIDATION = {
+		canceledForLiquidation: {},
+	};
+	static readonly MARKET_ORDER_AUCTION_EXPIRED = {
+		marketOrderAuctionExpired: {},
+	};
 }
 
 export class OrderTriggerCondition {
@@ -161,20 +167,78 @@ 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;
+	liquidationId: number;
+	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 SettlePnlRecord = {
+	ts: BN;
+	marketIndex: BN;
+	pnl: BN;
+	baseAssetAmount: BN;
+	quoteAssetAmountAfter: BN;
+	quoteEntryamount: BN;
+	oraclePrice: BN;
 };
 
 export type OrderRecord = {
@@ -183,8 +247,8 @@ export type OrderRecord = {
 	maker: PublicKey;
 	takerOrder: Order;
 	makerOrder: Order;
-	takerUnsettledPnl: BN;
-	makerUnsettledPnl: BN;
+	takerPnl: BN;
+	makerPnl: BN;
 	action: OrderAction;
 	actionExplanation: OrderActionExplanation;
 	filler: PublicKey;
@@ -241,9 +305,13 @@ export type MarketAccount = {
 	openInterest: BN;
 	marginRatioInitial: number;
 	marginRatioMaintenance: number;
-	marginRatioPartial: number;
 	nextFillRecordId: BN;
 	pnlPool: PoolBalance;
+	liquidationFee: BN;
+	imfFactor: BN;
+	unsettledImfFactor: BN;
+	unsettledInitialAssetWeight: number;
+	unsettledMaintenanceAssetWeight: number;
 };
 
 export type BankAccount = {
@@ -267,6 +335,8 @@ export type BankAccount = {
 	maintenanceAssetWeight: BN;
 	initialLiabilityWeight: BN;
 	maintenanceLiabilityWeight: BN;
+	liquidationFee: BN;
+	imfFactor: BN;
 };
 
 export type PoolBalance = {
@@ -328,7 +398,6 @@ export type UserPosition = {
 	quoteAssetAmount: BN;
 	quoteEntryAmount: BN;
 	openOrders: BN;
-	unsettledPnl: BN;
 	openBids: BN;
 	openAsks: BN;
 };
@@ -349,6 +418,8 @@ export type UserAccount = {
 	};
 	positions: UserPosition[];
 	orders: Order[];
+	beingLiquidated: boolean;
+	nextLiquidationId: number;
 };
 
 export type UserBankBalance = {
@@ -493,6 +564,7 @@ export type FeeStructure = {
 	makerRebateNumerator: BN;
 	makerRebateDenominator: BN;
 	fillerRewardStructure: OrderFillerRewardStructure;
+	cancelOrderFee: BN;
 };
 
 export type OracleGuardRails = {
@@ -514,4 +586,4 @@ export type OrderFillerRewardStructure = {
 	timeBasedRewardLowerBound: BN;
 };
 
-export type MarginCategory = 'Initial' | 'Partial' | 'Maintenance';
+export type MarginCategory = 'Initial' | 'Maintenance';

package/src/{accounts/fetch.js → util/computeUnits.js}

@@ -9,21 +9,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchUserAccounts = void 0;
-const pda_1 = require("../addresses/pda");
-function fetchUserAccounts(connection, program, authority, limit = 8) {
+exports.findComputeUnitConsumption = void 0;
+function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
     return __awaiter(this, void 0, void 0, function* () {
-        const userAccountPublicKeys = new Array();
-        for (let i = 0; i < limit; i++) {
-            userAccountPublicKeys.push(yield pda_1.getUserAccountPublicKey(program.programId, authority, i));
-        }
-        const accountInfos = yield connection.getMultipleAccountsInfo(userAccountPublicKeys, 'confirmed');
-        return accountInfos.map((accountInfo) => {
-            if (!accountInfo) {
-                return undefined;
+        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 program.account.user.coder.accounts.decode('User', accountInfo.data);
         });
+        return computeUnits;
     });
 }
-exports.fetchUserAccounts = fetchUserAccounts;
+exports.findComputeUnitConsumption = findComputeUnitConsumption;

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);