@drift-labs/sdk 0.1.36-master.4 → 0.1.36-master.7

package/src/clearingHouse.ts

@@ -22,6 +22,7 @@ import {
 	Order,
 	ExtendedCurveHistoryAccount,
 	UserPositionsAccount,
+	SettlementStateAccount,
 } from './types';
 import * as anchor from '@project-serum/anchor';
 import clearingHouseIDL from './idl/clearing_house.json';
@@ -42,6 +43,7 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import {
 	getClearingHouseStateAccountPublicKey,
 	getOrderStateAccountPublicKey,
+	getSettlementStatePublicKey,
 	getUserAccountPublicKey,
 	getUserAccountPublicKeyAndNonce,
 	getUserOrdersAccountPublicKey,
@@ -56,9 +58,17 @@ import { TxSender } from './tx/types';
 import { wrapInTx } from './tx/utils';
 import {
 	getClearingHouse,
+	getPollingClearingHouseConfig,
 	getWebSocketClearingHouseConfig,
 } from './factory/clearingHouse';
 import { ZERO } from './constants/numericConstants';
+import { BulkAccountLoader } from './accounts/bulkAccountLoader';
+import { ClearingHouseUser } from './clearingHouseUser';
+import {
+	getClearingHouseUser,
+	getPollingClearingHouseUserConfig,
+} from './factory/clearingHouseUser';
+import { bulkPollingUserSubscribe } from './accounts/bulkUserSubscription';
 
 /**
  * # ClearingHouse
@@ -186,6 +196,13 @@ export class ClearingHouse {
 		return this.accountSubscriber.getStateAccount();
 	}
 
+	public async getSettlementAccount(): Promise<SettlementStateAccount> {
+		// @ts-ignore
+		return await this.program.account.settlementState.fetch(
+			await getSettlementStatePublicKey(this.program.programId)
+		);
+	}
+
 	public getMarketsAccount(): MarketsAccount {
 		return this.accountSubscriber.getMarketsAccount();
 	}
@@ -917,17 +934,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();
@@ -944,7 +963,7 @@ export class ClearingHouse {
 			});
 		}
 
-		return await this.program.instruction.cancelAllOrders({
+		return await this.program.instruction.cancelAllOrders(bestEffort, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user: userAccountPublicKey,
@@ -961,6 +980,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,
@@ -1340,4 +1422,122 @@ export class ClearingHouse {
 	public triggerEvent(eventName: keyof ClearingHouseAccountEvents, data?: any) {
 		this.eventEmitter.emit(eventName, data);
 	}
+
+	public async settlePositionAndClaimCollateral(
+		collateralAccountPublicKey: PublicKey
+	): Promise<TransactionSignature> {
+		const settlePositionIx = await this.getSettlePositionIx();
+		const claimCollateralIx = await this.getClaimCollateralIx(
+			collateralAccountPublicKey
+		);
+		const tx = new Transaction().add(settlePositionIx).add(claimCollateralIx);
+
+		return this.txSender.send(tx, [], this.opts);
+	}
+
+	public async getSettlePositionIx(): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const user: any = await this.program.account.user.fetch(
+			userAccountPublicKey
+		);
+		const state = this.getStateAccount();
+
+		const settlementState = await getSettlementStatePublicKey(
+			this.program.programId
+		);
+
+		return await this.program.instruction.settlePosition({
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				markets: state.markets,
+				authority: this.wallet.publicKey,
+				userPositions: user.positions,
+				settlementState,
+				fundingPaymentHistory: state.fundingPaymentHistory,
+			},
+		});
+	}
+
+	public async getClaimCollateralIx(
+		collateralAccountPublicKey: PublicKey
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const state = this.getStateAccount();
+
+		const settlementState = await getSettlementStatePublicKey(
+			this.program.programId
+		);
+
+		return await this.program.instruction.claimCollateral({
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				collateralVault: state.collateralVault,
+				collateralVaultAuthority: state.collateralVaultAuthority,
+				userCollateralAccount: collateralAccountPublicKey,
+				authority: this.wallet.publicKey,
+				tokenProgram: TOKEN_PROGRAM_ID,
+				settlementState,
+			},
+		});
+	}
+
+	public async getTotalSettlementSize(): Promise<BN> {
+		const accountLoader = new BulkAccountLoader(
+			this.connection,
+			'processed',
+			50000
+		);
+		const clearingHouse = getClearingHouse(
+			getPollingClearingHouseConfig(
+				this.connection,
+				this.wallet,
+				this.program.programId,
+				accountLoader
+			)
+		);
+
+		console.log('loading all users');
+		const programUserAccounts =
+			(await this.program.account.user.all()) as any[];
+		const userArray: ClearingHouseUser[] = [];
+		for (const programUserAccount of programUserAccounts) {
+			const user = getClearingHouseUser(
+				getPollingClearingHouseUserConfig(
+					clearingHouse,
+					programUserAccount.account.authority,
+					accountLoader
+				)
+			);
+			userArray.push(user);
+		}
+
+		console.log('subscribing all users');
+		await bulkPollingUserSubscribe(userArray, accountLoader);
+
+		console.log('calculating settlement size');
+		const settlementSize = userArray.reduce((collateralToBeSettled, user) => {
+			return collateralToBeSettled.add(
+				user.getUserAccount().forgoPositionSettlement === 0
+					? user.getSettledPositionValue()
+					: ZERO
+			);
+		}, ZERO);
+
+		for (const user of userArray) {
+			await user.unsubscribe();
+		}
+
+		return settlementSize;
+	}
+
+	public async updateUserForgoSettlement(): Promise<TransactionSignature> {
+		return await this.program.rpc.updateUserForgoSettlement({
+			accounts: {
+				authority: this.wallet.publicKey,
+				user: await this.getUserAccountPublicKey(),
+			},
+		});
+	}
 }

package/src/clearingHouseUser.ts

@@ -6,12 +6,16 @@ import {
 	isVariant,
 	MarginCategory,
 	Order,
+	SettlementStateAccount,
 	UserAccount,
 	UserOrdersAccount,
 	UserPosition,
 	UserPositionsAccount,
 } from './types';
-import { calculateEntryPrice } from './math/position';
+import {
+	calculateEntryPrice,
+	calculateSettledPositionPNL,
+} from './math/position';
 import {
 	MARK_PRICE_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
@@ -833,4 +837,63 @@ export class ClearingHouseUser {
 
 		return this.getTotalPositionValue().sub(currentMarketPositionValueUSDC);
 	}
+
+	public getClaimableCollateral(settlementState: SettlementStateAccount): BN {
+		return this.getSettledPositionValue()
+			.mul(
+				settlementState.collateralAvailableToClaim.sub(
+					this.getUserAccount().lastCollateralAvailableToClaim
+				)
+			)
+			.div(settlementState.totalSettlementValue);
+	}
+
+	public getSettledPositionValue(): BN {
+		return BN.max(
+			this.getUserAccount()
+				.collateral.add(
+					this.getUnrealizedFundingPNL().div(PRICE_TO_QUOTE_PRECISION)
+				)
+				.add(this.getSettledPositionsPNL()),
+			ZERO
+		);
+	}
+
+	public getSettledPositionsPNL(): BN {
+		return this.getUserPositionsAccount().positions.reduce(
+			(pnl, marketPosition) => {
+				const market = this.clearingHouse.getMarket(marketPosition.marketIndex);
+				return pnl.add(calculateSettledPositionPNL(market, marketPosition));
+			},
+			ZERO
+		);
+	}
+
+	public async estimateClaimableCollateral(): Promise<BN> {
+		const currentCollateralVaultBalance = new BN(
+			(
+				await this.clearingHouse.connection.getTokenAccountBalance(
+					this.clearingHouse.getStateAccount().collateralVault
+				)
+			).value.amount
+		);
+		const currentInsuranceVaultBalance = new BN(
+			(
+				await this.clearingHouse.connection.getTokenAccountBalance(
+					this.clearingHouse.getStateAccount().insuranceVault
+				)
+			).value.amount
+		);
+
+		const totalClaimableCollateral = currentCollateralVaultBalance.add(
+			currentInsuranceVaultBalance
+		);
+		const totalEstimatedSettlementValue =
+			await this.clearingHouse.getTotalSettlementSize();
+		const userSettledPositionValue = await this.getSettledPositionValue();
+
+		return totalClaimableCollateral
+			.mul(userSettledPositionValue)
+			.div(totalEstimatedSettlementValue);
+	}
 }