@drift-labs/sdk 0.2.0-master.20 → 0.2.0-master.23

package/src/clearingHouse.ts

@@ -40,6 +40,7 @@ import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import {
 	getClearingHouseStateAccountPublicKey,
+	getInsuranceFundStakeAccountPublicKey,
 	getMarketPublicKey,
 	getUserAccountPublicKey,
 	getUserAccountPublicKeySync,
@@ -224,11 +225,13 @@ export class ClearingHouse {
 	 *	Forces the accountSubscriber to fetch account updates from rpc
 	 */
 	public async fetchAccounts(): Promise<void> {
-		await Promise.all(
-			[...this.users.values()]
-				.map((user) => user.fetchAccounts())
-				.concat(this.accountSubscriber.fetch())
-		);
+		const promises = [...this.users.values()]
+			.map((user) => user.fetchAccounts())
+			.concat(this.accountSubscriber.fetch());
+		if (this.userStats) {
+			promises.concat(this.userStats.fetchAccounts());
+		}
+		await Promise.all(promises);
 	}
 
 	public async unsubscribe(): Promise<void> {
@@ -1764,7 +1767,9 @@ export class ClearingHouse {
 		const userStatsPublicKey = this.getUserStatsAccountPublicKey();
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccounts({
+		// todo merge this with getRemainingAccounts
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+			counterPartyUserAccount: takerInfo.takerUserAccount,
 			writableMarketIndex: orderParams.marketIndex,
 		});
 
@@ -1985,9 +1990,9 @@ export class ClearingHouse {
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
 		const liquidatorStatsPublicKey = this.getUserStatsAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccountsForLiquidation({
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
 			writableMarketIndex: marketIndex,
-			userAccount,
+			counterPartyUserAccount: userAccount,
 		});
 
 		return await this.program.instruction.liquidatePerp(
@@ -2039,8 +2044,8 @@ export class ClearingHouse {
 	): Promise<TransactionInstruction> {
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccountsForLiquidation({
-			userAccount,
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+			counterPartyUserAccount: userAccount,
 			writableBankIndexes: [liabilityBankIndex, assetBankIndex],
 		});
 
@@ -2092,8 +2097,8 @@ export class ClearingHouse {
 	): Promise<TransactionInstruction> {
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccountsForLiquidation({
-			userAccount,
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+			counterPartyUserAccount: userAccount,
 			writableMarketIndex: perpMarketIndex,
 			writableBankIndexes: [liabilityBankIndex],
 		});
@@ -2146,8 +2151,8 @@ export class ClearingHouse {
 	): Promise<TransactionInstruction> {
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccountsForLiquidation({
-			userAccount,
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
+			counterPartyUserAccount: userAccount,
 			writableMarketIndex: perpMarketIndex,
 			writableBankIndexes: [assetBankIndex],
 		});
@@ -2171,6 +2176,7 @@ export class ClearingHouse {
 	public async resolvePerpBankruptcy(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
+		bankIndex: BN,
 		marketIndex: BN
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
@@ -2178,6 +2184,7 @@ export class ClearingHouse {
 				await this.getResolvePerpBankruptcyIx(
 					userAccountPublicKey,
 					userAccount,
+					bankIndex,
 					marketIndex
 				)
 			),
@@ -2190,24 +2197,36 @@ export class ClearingHouse {
 	public async getResolvePerpBankruptcyIx(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
+		bankIndex: BN,
 		marketIndex: BN
 	): Promise<TransactionInstruction> {
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccountsForLiquidation({
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
 			writableMarketIndex: marketIndex,
-			userAccount,
+			writableBankIndexes: [bankIndex],
+			counterPartyUserAccount: userAccount,
 		});
 
-		return await this.program.instruction.resolvePerpBankruptcy(marketIndex, {
-			accounts: {
-				state: await this.getStatePublicKey(),
-				authority: this.wallet.publicKey,
-				user: userAccountPublicKey,
-				liquidator: liquidatorPublicKey,
-			},
-			remainingAccounts: remainingAccounts,
-		});
+		const bank = this.getBankAccount(bankIndex);
+
+		return await this.program.instruction.resolvePerpBankruptcy(
+			bankIndex,
+			marketIndex,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					authority: this.wallet.publicKey,
+					user: userAccountPublicKey,
+					liquidator: liquidatorPublicKey,
+					bankVault: bank.vault,
+					insuranceFundVault: bank.insuranceFundVault,
+					insuranceFundVaultAuthority: bank.insuranceFundVaultAuthority,
+					tokenProgram: TOKEN_PROGRAM_ID,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
 	}
 
 	public async resolveBorrowBankruptcy(
@@ -2236,33 +2255,39 @@ export class ClearingHouse {
 	): Promise<TransactionInstruction> {
 		const liquidatorPublicKey = await this.getUserAccountPublicKey();
 
-		const remainingAccounts = this.getRemainingAccountsForLiquidation({
+		const remainingAccounts = this.getRemainingAccountsWithCounterparty({
 			writableBankIndexes: [bankIndex],
-			userAccount,
+			counterPartyUserAccount: userAccount,
 		});
 
+		const bank = this.getBankAccount(bankIndex);
+
 		return await this.program.instruction.resolveBorrowBankruptcy(bankIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				authority: this.wallet.publicKey,
 				user: userAccountPublicKey,
 				liquidator: liquidatorPublicKey,
+				bankVault: bank.vault,
+				insuranceFundVault: bank.insuranceFundVault,
+				insuranceFundVaultAuthority: bank.insuranceFundVaultAuthority,
+				tokenProgram: TOKEN_PROGRAM_ID,
 			},
 			remainingAccounts: remainingAccounts,
 		});
 	}
 
-	getRemainingAccountsForLiquidation(params: {
-		userAccount: UserAccount;
+	getRemainingAccountsWithCounterparty(params: {
+		counterPartyUserAccount: UserAccount;
 		writableMarketIndex?: BN;
 		writableBankIndexes?: BN[];
 	}): AccountMeta[] {
-		const liquidateeUserAccount = params.userAccount;
+		const counterPartyUserAccount = params.counterPartyUserAccount;
 
 		const oracleAccountMap = new Map<string, AccountMeta>();
 		const bankAccountMap = new Map<number, AccountMeta>();
 		const marketAccountMap = new Map<number, AccountMeta>();
-		for (const bankBalance of liquidateeUserAccount.bankBalances) {
+		for (const bankBalance of counterPartyUserAccount.bankBalances) {
 			if (!bankBalance.balance.eq(ZERO)) {
 				const bankAccount = this.getBankAccount(bankBalance.bankIndex);
 				bankAccountMap.set(bankBalance.bankIndex.toNumber(), {
@@ -2280,7 +2305,7 @@ export class ClearingHouse {
 				}
 			}
 		}
-		for (const position of liquidateeUserAccount.positions) {
+		for (const position of counterPartyUserAccount.positions) {
 			if (!positionIsAvailable(position)) {
 				const market = this.getMarketAccount(position.marketIndex);
 				marketAccountMap.set(position.marketIndex.toNumber(), {
@@ -2476,4 +2501,191 @@ export class ClearingHouse {
 
 		return oracleData;
 	}
+
+	public async initializeInsuranceFundStake(
+		bankIndex: BN
+	): Promise<TransactionSignature> {
+		const { txSig } = await this.txSender.send(
+			wrapInTx(await this.getInitializeInsuranceFundStakeIx(bankIndex)),
+			[],
+			this.opts
+		);
+		return txSig;
+	}
+
+	public async getInitializeInsuranceFundStakeIx(
+		bankIndex: BN
+	): Promise<TransactionInstruction> {
+		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			bankIndex
+		);
+
+		return await this.program.instruction.initializeInsuranceFundStake(
+			bankIndex,
+			{
+				accounts: {
+					insuranceFundStake: ifStakeAccountPublicKey,
+					bank: this.getBankAccount(bankIndex).pubkey,
+					userStats: this.getUserStatsAccountPublicKey(),
+					authority: this.wallet.publicKey,
+					payer: this.wallet.publicKey,
+					rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+					systemProgram: anchor.web3.SystemProgram.programId,
+					state: await this.getStatePublicKey(),
+				},
+			}
+		);
+	}
+
+	public async addInsuranceFundStake(
+		bankIndex: BN,
+		amount: BN,
+		collateralAccountPublicKey: PublicKey
+	): Promise<TransactionSignature> {
+		const bank = this.getBankAccount(bankIndex);
+		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			bankIndex
+		);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			writableBankIndex: bankIndex,
+		});
+
+		return await this.program.rpc.addInsuranceFundStake(bankIndex, amount, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				bank: bank.pubkey,
+				insuranceFundStake: ifStakeAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
+				authority: this.wallet.publicKey,
+				insuranceFundVault: bank.insuranceFundVault,
+				userTokenAccount: collateralAccountPublicKey,
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+			remainingAccounts,
+		});
+	}
+
+	public async requestRemoveInsuranceFundStake(
+		bankIndex: BN,
+		amount: BN
+	): Promise<TransactionSignature> {
+		const bank = this.getBankAccount(bankIndex);
+		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			bankIndex
+		);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			writableBankIndex: bankIndex,
+		});
+
+		return await this.program.rpc.requestRemoveInsuranceFundStake(
+			bankIndex,
+			amount,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					bank: bank.pubkey,
+					insuranceFundStake: ifStakeAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
+					authority: this.wallet.publicKey,
+					insuranceFundVault: bank.insuranceFundVault,
+					// userTokenAccount: collateralAccountPublicKey,
+					// tokenProgram: TOKEN_PROGRAM_ID,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
+	public async cancelRequestRemoveInsuranceFundStake(
+		bankIndex: BN
+	): Promise<TransactionSignature> {
+		const bank = this.getBankAccount(bankIndex);
+		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			bankIndex
+		);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			writableBankIndex: bankIndex,
+		});
+
+		return await this.program.rpc.cancelRequestRemoveInsuranceFundStake(
+			bankIndex,
+			{
+				accounts: {
+					state: await this.getStatePublicKey(),
+					bank: bank.pubkey,
+					insuranceFundStake: ifStakeAccountPublicKey,
+					userStats: this.getUserStatsAccountPublicKey(),
+					authority: this.wallet.publicKey,
+					insuranceFundVault: bank.insuranceFundVault,
+					// userTokenAccount: collateralAccountPublicKey,
+					// tokenProgram: TOKEN_PROGRAM_ID,
+				},
+				remainingAccounts,
+			}
+		);
+	}
+
+	public async removeInsuranceFundStake(
+		bankIndex: BN,
+		collateralAccountPublicKey: PublicKey
+	): Promise<TransactionSignature> {
+		const bank = this.getBankAccount(bankIndex);
+		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
+			this.program.programId,
+			this.wallet.publicKey,
+			bankIndex
+		);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			writableBankIndex: bankIndex,
+		});
+
+		return await this.program.rpc.removeInsuranceFundStake(bankIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				bank: bank.pubkey,
+				insuranceFundStake: ifStakeAccountPublicKey,
+				userStats: this.getUserStatsAccountPublicKey(),
+				authority: this.wallet.publicKey,
+				insuranceFundVault: bank.insuranceFundVault,
+				insuranceFundVaultAuthority: bank.insuranceFundVaultAuthority,
+				userTokenAccount: collateralAccountPublicKey,
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+			remainingAccounts,
+		});
+	}
+
+	public async settleRevenueToInsuranceFund(
+		bankIndex: BN
+	): Promise<TransactionSignature> {
+		const bank = this.getBankAccount(bankIndex);
+
+		const remainingAccounts = this.getRemainingAccounts({
+			writableBankIndex: bankIndex,
+		});
+
+		return await this.program.rpc.settleRevenueToInsuranceFund(bankIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				bank: bank.pubkey,
+				bankVault: bank.vault,
+				bankVaultAuthority: bank.vaultAuthority,
+				insuranceFundVault: bank.insuranceFundVault,
+				tokenProgram: TOKEN_PROGRAM_ID,
+			},
+			remainingAccounts,
+		});
+	}
 }

package/src/clearingHouseUser.ts

@@ -46,7 +46,7 @@ import {
 	calculateLiabilityWeight,
 } from './math/bankBalance';
 import {
-	calculateMarginBaseAssetValue,
+	calculateBaseAssetValueWithOracle,
 	calculateWorstCaseBaseAssetAmount,
 } from './math/margin';
 import { OraclePriceData } from './oracles/types';
@@ -144,6 +144,11 @@ export class ClearingHouseUser {
 		};
 	}
 
+	public getClonedPosition(position: UserPosition): UserPosition {
+		const clonedPosition = Object.assign({}, position);
+		return clonedPosition;
+	}
+
 	/**
 	 * @param orderId
 	 * @returns Order
@@ -180,8 +185,10 @@ export class ClearingHouseUser {
 	 * calculates the market position if the lp position was settled
 	 * @returns : userPosition
 	 */
-	public getSettledLPPosition(marketIndex: BN): [UserPosition, BN] {
-		const position = this.getUserPosition(marketIndex);
+	public getSettledLPPosition(marketIndex: BN): [UserPosition, BN, BN] {
+		const _position = this.getUserPosition(marketIndex);
+		const position = this.getClonedPosition(_position);
+
 		const market = this.clearingHouse.getMarketAccount(position.marketIndex);
 		const nShares = position.lpShares;
 
@@ -265,7 +272,7 @@ export class ClearingHouseUser {
 			position.lastCumulativeFundingRate = ZERO;
 		}
 
-		return [position, pnl];
+		return [position, remainderBaa, pnl];
 	}
 
 	/**
@@ -289,51 +296,55 @@ export class ClearingHouseUser {
 		return freeCollateral.gte(ZERO) ? freeCollateral : ZERO;
 	}
 
-	public getInitialMarginRequirement(): BN {
-		const postionMarginRequirement = this.getUserAccount().positions.reduce(
-			(marginRequirement, marketPosition) => {
+	/**
+	 * @returns The margin requirement of a certain type (Initial or Maintenance) in USDC. : QUOTE_PRECISION
+	 */
+	public getMarginRequirement(type: MarginCategory): BN {
+		return this.getUserAccount()
+			.positions.reduce((marginRequirement, marketPosition) => {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
-				const worstCaseBaseAssetAmount =
-					calculateWorstCaseBaseAssetAmount(marketPosition);
 
-				const worstCaseAssetValue = worstCaseBaseAssetAmount
-					.abs()
-					.mul(this.getOracleDataForMarket(market.marketIndex).price)
-					.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+				if (marketPosition.lpShares.gt(ZERO)) {
+					// is an lp
+					// clone so we dont mutate the position
+					marketPosition = this.getClonedPosition(marketPosition);
 
-				const marketMarginRatio = new BN(
-					calculateMarketMarginRatio(
-						market,
-						worstCaseBaseAssetAmount.abs(),
-						'Initial'
-					)
-				);
-				return marginRequirement.add(
-					worstCaseAssetValue.mul(marketMarginRatio).div(MARGIN_PRECISION)
-				);
-			},
-			ZERO
-		);
+					// settle position
+					const [settledPosition, dustBaa, _] = this.getSettledLPPosition(
+						market.marketIndex
+					);
+					marketPosition.baseAssetAmount =
+						settledPosition.baseAssetAmount.add(dustBaa);
+					marketPosition.quoteAssetAmount = settledPosition.quoteAssetAmount;
+
+					// open orders
+					let openAsks;
+					if (market.amm.maxBaseAssetReserve > market.amm.baseAssetReserve) {
+						openAsks = market.amm.maxBaseAssetReserve
+							.sub(market.amm.baseAssetReserve)
+							.mul(marketPosition.lpShares)
+							.div(market.amm.sqrtK)
+							.mul(new BN(-1));
+					} else {
+						openAsks = ZERO;
+					}
 
-		const bankMarginRequirement = this.getBankLiabilityValue(
-			undefined,
-			'Initial'
-		);
+					let openBids;
+					if (market.amm.minBaseAssetReserve < market.amm.baseAssetReserve) {
+						openBids = market.amm.baseAssetReserve
+							.sub(market.amm.minBaseAssetReserve)
+							.mul(marketPosition.lpShares)
+							.div(market.amm.sqrtK);
+					} else {
+						openBids = ZERO;
+					}
 
-		return bankMarginRequirement.add(postionMarginRequirement);
-	}
+					marketPosition.openAsks = marketPosition.openAsks.add(openAsks);
+					marketPosition.openBids = marketPosition.openBids.add(openBids);
+				}
 
-	/**
-	 * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
-	 */
-	public getMaintenanceMarginRequirement(): BN {
-		return this.getUserAccount()
-			.positions.reduce((marginRequirement, marketPosition) => {
-				const market = this.clearingHouse.getMarketAccount(
-					marketPosition.marketIndex
-				);
 				const worstCaseBaseAssetAmount =
 					calculateWorstCaseBaseAssetAmount(marketPosition);
 
@@ -349,14 +360,28 @@ export class ClearingHouseUser {
 								calculateMarketMarginRatio(
 									market,
 									worstCaseBaseAssetAmount.abs(),
-									'Maintenance'
+									type
 								)
 							)
 						)
 						.div(MARGIN_PRECISION)
 				);
 			}, ZERO)
-			.add(this.getBankLiabilityValue(undefined, 'Maintenance'));
+			.add(this.getBankLiabilityValue(undefined, type));
+	}
+
+	/**
+	 * @returns The initial margin requirement in USDC. : QUOTE_PRECISION
+	 */
+	public getInitialMarginRequirement(): BN {
+		return this.getMarginRequirement('Initial');
+	}
+
+	/**
+	 * @returns The maintenance margin requirement in USDC. : QUOTE_PRECISION
+	 */
+	public getMaintenanceMarginRequirement(): BN {
+		return this.getMarginRequirement('Maintenance');
 	}
 
 	/**
@@ -543,7 +568,7 @@ export class ClearingHouseUser {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
-				const posVal = calculateMarginBaseAssetValue(
+				const posVal = calculateBaseAssetValueWithOracle(
 					market,
 					marketPosition,
 					this.getOracleDataForMarket(market.marketIndex)
@@ -568,7 +593,11 @@ export class ClearingHouseUser {
 		const market = this.clearingHouse.getMarketAccount(
 			userPosition.marketIndex
 		);
-		return calculateMarginBaseAssetValue(market, userPosition, oraclePriceData);
+		return calculateBaseAssetValueWithOracle(
+			market,
+			userPosition,
+			oraclePriceData
+		);
 	}
 
 	public getPositionSide(
@@ -619,7 +648,7 @@ export class ClearingHouseUser {
 				oraclePriceData
 			);
 		} else {
-			baseAssetValue = calculateMarginBaseAssetValue(
+			baseAssetValue = calculateBaseAssetValueWithOracle(
 				market,
 				position,
 				oraclePriceData
@@ -793,7 +822,7 @@ export class ClearingHouseUser {
 			proposedMarketPosition.marketIndex
 		);
 
-		const proposedMarketPositionValue = calculateMarginBaseAssetValue(
+		const proposedMarketPositionValue = calculateBaseAssetValueWithOracle(
 			market,
 			proposedMarketPosition,
 			this.getOracleDataForMarket(market.marketIndex)
@@ -810,7 +839,7 @@ export class ClearingHouseUser {
 						const market = this.clearingHouse.getMarketAccount(
 							position.marketIndex
 						);
-						const positionValue = calculateMarginBaseAssetValue(
+						const positionValue = calculateBaseAssetValueWithOracle(
 							market,
 							position,
 							this.getOracleDataForMarket(market.marketIndex)

package/src/config.ts

@@ -28,7 +28,7 @@ export const configs: { [key in DriftEnv]: DriftConfig } = {
 	devnet: {
 		ENV: 'devnet',
 		PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-		CLEARING_HOUSE_PROGRAM_ID: '65sz7dRiWDRPZjiRxcTxPM7AE6VK4Nag9HEK6oBJXhJn',
+		CLEARING_HOUSE_PROGRAM_ID: 'AXmmKr4MHipFp4SDr6CTUBzJtD1rZPHTzPDVPJ6L6r64',
 		USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
 		MARKETS: DevnetMarkets,
 		BANKS: DevnetBanks,

package/src/constants/banks.ts

@@ -1,5 +1,11 @@
 import { PublicKey } from '@solana/web3.js';
 import { BN, DriftEnv, OracleSource } from '../';
+import {
+	BANK_BALANCE_PRECISION,
+	BANK_BALANCE_PRECISION_EXP,
+	LAMPORTS_EXP,
+	LAMPORTS_PRECISION,
+} from './numericConstants';
 
 export type BankConfig = {
 	symbol: string;
@@ -7,6 +13,8 @@ export type BankConfig = {
 	oracle: PublicKey;
 	mint: PublicKey;
 	oracleSource: OracleSource;
+	precision: BN;
+	precisionExp: BN;
 };
 
 export const WRAPPED_SOL_MINT = new PublicKey(
@@ -20,6 +28,8 @@ export const DevnetBanks: BankConfig[] = [
 		oracle: PublicKey.default,
 		oracleSource: OracleSource.QUOTE_ASSET,
 		mint: new PublicKey('8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2'),
+		precision: BANK_BALANCE_PRECISION,
+		precisionExp: BANK_BALANCE_PRECISION_EXP,
 	},
 	{
 		symbol: 'SOL',
@@ -27,6 +37,8 @@ export const DevnetBanks: BankConfig[] = [
 		oracle: new PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
 		oracleSource: OracleSource.PYTH,
 		mint: new PublicKey(WRAPPED_SOL_MINT),
+		precision: LAMPORTS_PRECISION,
+		precisionExp: LAMPORTS_EXP,
 	},
 	{
 		symbol: 'BTC',
@@ -34,6 +46,8 @@ export const DevnetBanks: BankConfig[] = [
 		oracle: new PublicKey('HovQMDrbAgAYPCmHVSrezcSmkMtXSSUsLDFANExrZh2J'),
 		oracleSource: OracleSource.PYTH,
 		mint: new PublicKey('3BZPwbcqB5kKScF3TEXxwNfx5ipV13kbRVDvfVp5c6fv'),
+		precision: BANK_BALANCE_PRECISION,
+		precisionExp: BANK_BALANCE_PRECISION_EXP,
 	},
 ];
 
@@ -44,6 +58,8 @@ export const MainnetBanks: BankConfig[] = [
 		oracle: PublicKey.default,
 		oracleSource: OracleSource.QUOTE_ASSET,
 		mint: new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
+		precision: BANK_BALANCE_PRECISION,
+		precisionExp: BANK_BALANCE_PRECISION_EXP,
 	},
 ];
 

package/src/constants/numericConstants.ts

@@ -1,3 +1,4 @@
+import { LAMPORTS_PER_SOL } from '@solana/web3.js';
 import { BN } from '../';
 
 export const ZERO = new BN(0);
@@ -66,3 +67,6 @@ export const BID_ASK_SPREAD_PRECISION = new BN(1000000);
 export const ONE_YEAR = new BN(31536000);
 
 export const QUOTE_ASSET_BANK_INDEX = new BN(0);
+
+export const LAMPORTS_PRECISION = new BN(LAMPORTS_PER_SOL);
+export const LAMPORTS_EXP = new BN(Math.log10(LAMPORTS_PER_SOL));