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

package/lib/math/position.d.ts

@@ -18,6 +18,7 @@ export declare function calculateBaseAssetValue(market: Market, userPosition: Us
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 export declare function calculatePositionPNL(market: Market, marketPosition: UserPosition, withFunding?: boolean): BN;
+export declare function calculateSettledPositionPNL(market: Market, marketPosition: UserPosition): BN;
 /**
  *
  * @param market

package/lib/math/position.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.calculatePositionFundingPNL = exports.calculateSettledPositionPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
 const __1 = require("../");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
+const settlement_1 = require("../settlement");
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -60,6 +61,23 @@ function calculatePositionPNL(market, marketPosition, withFunding = false) {
     return pnl;
 }
 exports.calculatePositionPNL = calculatePositionPNL;
+function calculateSettledPositionPNL(market, marketPosition) {
+    let pnl = calculatePositionPNL(market, marketPosition);
+    if (pnl.gt(numericConstants_1.ZERO)) {
+        try {
+            pnl = pnl
+                .mul(new __1.BN(settlement_1.SETTLEMENT_RATIOS[marketPosition.marketIndex.toNumber()]))
+                .div(settlement_1.SETTLEMENT_RATIO_PRECISION);
+        }
+        catch (e) {
+            console.log(pnl.toString());
+            console.log(marketPosition.marketIndex.toNumber());
+            throw e;
+        }
+    }
+    return pnl;
+}
+exports.calculateSettledPositionPNL = calculateSettledPositionPNL;
 /**
  *
  * @param market

package/lib/settlement.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="bn.js" />
+import { BN } from '@project-serum/anchor';
+export declare const SETTLEMENT_RATIO_PRECISION: BN;
+export declare const SETTLEMENT_RATIOS: number[];

package/lib/settlement.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SETTLEMENT_RATIOS = exports.SETTLEMENT_RATIO_PRECISION = void 0;
+const anchor_1 = require("@project-serum/anchor");
+exports.SETTLEMENT_RATIO_PRECISION = new anchor_1.BN(1000000);
+exports.SETTLEMENT_RATIOS = [
+    291786, 243613, 712271, 293771, 555181, 604938, 241133, 218489, 251741,
+    883058, 51614, 531737, 956092, 106424, 727107, 477277, 217325, 127477, 248561,
+    565938, 59349,
+];

package/lib/types.d.ts

@@ -275,6 +275,12 @@ export declare type OrderStateAccount = {
     orderFillerRewardStructure: OrderFillerRewardStructure;
     minOrderQuoteAssetAmount: BN;
 };
+export declare type SettlementStateAccount = {
+    totalSettlementValue: BN;
+    collateralAvailableToClaim: BN;
+    collateralClaimed: BN;
+    enabled: boolean;
+};
 export declare type MarketsAccount = {
     markets: Market[];
 };
@@ -337,6 +343,11 @@ export declare type UserAccount = {
     totalTokenDiscount: BN;
     totalReferralReward: BN;
     totalRefereeDiscount: BN;
+    settledPositionValue: BN;
+    collateralClaimed: BN;
+    lastCollateralAvailableToClaim: BN;
+    forgoPositionSettlement: number;
+    hasSettledPosition: number;
 };
 export declare type UserOrdersAccount = {
     orders: Order[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.36-master.6",
+	"version": "0.1.36-master.7",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/addresses.ts

@@ -69,3 +69,14 @@ export async function getUserOrdersAccountPublicKey(
 		await getUserOrdersAccountPublicKeyAndNonce(programId, userAccount)
 	)[0];
 }
+
+export async function getSettlementStatePublicKey(
+	programId: PublicKey
+): Promise<PublicKey> {
+	return (
+		await anchor.web3.PublicKey.findProgramAddress(
+			[Buffer.from(anchor.utils.bytes.utf8.encode('settlement_state'))],
+			programId
+		)
+	)[0];
+}

package/src/admin.ts

@@ -18,6 +18,8 @@ import {
 	getClearingHouseStateAccountPublicKey,
 	getClearingHouseStateAccountPublicKeyAndNonce,
 	getOrderStateAccountPublicKeyAndNonce,
+	getSettlementStatePublicKey,
+	getUserAccountPublicKey,
 } from './addresses';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { ClearingHouse } from './clearingHouse';
@@ -733,4 +735,85 @@ export class Admin extends ClearingHouse {
 			},
 		});
 	}
+
+	public async transferFromInsuranceVaultToCollateralVault(): Promise<TransactionSignature> {
+		const state = await this.getStateAccount();
+		return await this.program.rpc.transferFromInsuranceVaultToCollateralVault({
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				insuranceVault: state.insuranceVault,
+				insuranceVaultAuthority: state.insuranceVaultAuthority,
+				collateralVault: state.collateralVault,
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+		});
+	}
+
+	public async adminUpdateUserForgoSettlement(
+		authority: PublicKey
+	): Promise<TransactionSignature> {
+		const user = await getUserAccountPublicKey(
+			this.program.programId,
+			authority
+		);
+
+		return await this.program.rpc.adminUpdateUserForgoSettlement({
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				user: user,
+			},
+		});
+	}
+
+	public async initializeSettlementState(): Promise<TransactionSignature> {
+		const settlementState = await getSettlementStatePublicKey(
+			this.program.programId
+		);
+
+		const settlementSize = await this.getTotalSettlementSize();
+
+		return await this.program.rpc.initializeSettlementState(settlementSize, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				settlementState: settlementState,
+				rent: SYSVAR_RENT_PUBKEY,
+				systemProgram: anchor.web3.SystemProgram.programId,
+				collateralVault: (await this.getStateAccount()).collateralVault,
+			},
+		});
+	}
+
+	public async updateSettlementState(): Promise<TransactionSignature> {
+		const settlementState = await getSettlementStatePublicKey(
+			this.program.programId
+		);
+
+		return await this.program.rpc.updateSettlementState({
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				settlementState: settlementState,
+				collateralVault: (await this.getStateAccount()).collateralVault,
+			},
+		});
+	}
+
+	public async updateSettlementStateEnabled(
+		enabled: boolean
+	): Promise<TransactionSignature> {
+		const settlementState = await getSettlementStatePublicKey(
+			this.program.programId
+		);
+
+		return await this.program.rpc.updateSettlementStateEnabled(enabled, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				settlementState: settlementState,
+			},
+		});
+	}
 }

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();
 	}
@@ -1405,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);
+	}
 }