@drift-labs/sdk 0.2.0-master.29 → 0.2.0-master.30

package/README.md

@@ -54,13 +54,13 @@ a BigNum: 10,500,000, with precision 10^6, is equal to 10.5 because 10,500,000 /
 
 The Drift SDK uses some common precisions, which are available as constants to import from the SDK.
 
-| Precision Name            | Value |
-| ------------------------- | ----- |
-| QUOTE_PRECISION           | 10^6  |
-| MARK_PRICE_PRECISION      | 10^10 |
-| AMM_RESERVE_PRECISION     | 10^13 |
-| FUNDING_PAYMENT_PRECISION | 10^4  |
-| PEG_PRECISION             | 10^3  |
+| Precision Name        | Value |
+| --------------------- | ----- |
+| FUNDING_RATE_BUFFER   | 10^3  |
+| QUOTE_PRECISION       | 10^6  |
+| PEG_PRECISION         | 10^6  |
+| PRICE_PRECISION       | 10^6  |
+| AMM_RESERVE_PRECISION | 10^9  |
 
 **Important Note for BigNum division**
 
@@ -88,7 +88,7 @@ import { BN, Provider } from '@project-serum/anchor';
 import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import {
-	calculateMarkPrice,
+	calculateReservePrice,
 	ClearingHouse,
 	ClearingHouseUser,
 	initialize,
@@ -96,9 +96,9 @@ import {
 	PositionDirection,
 	convertToNumber,
 	calculateTradeSlippage,
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	QUOTE_PRECISION,
-	Wallet
+	Wallet,
 } from '@drift-labs/sdk';
 
 export const getTokenAddress = (
@@ -177,11 +177,11 @@ const main = async () => {
 		(market) => market.baseAssetSymbol === 'SOL'
 	);
 
-	const currentMarketPrice = calculateMarkPrice(
+	const currentMarketPrice = calculateReservePrice(
 		clearingHouse.getMarket(solMarketInfo.marketIndex)
 	);
 
-	const formattedPrice = convertToNumber(currentMarketPrice, MARK_PRICE_PRECISION);
+	const formattedPrice = convertToNumber(currentMarketPrice, PRICE_PRECISION);
 
 	console.log(`Current Market Price is $${formattedPrice}`);
 
@@ -194,7 +194,7 @@ const main = async () => {
 			new BN(5000).mul(QUOTE_PRECISION),
 			solMarketAccount
 		)[0],
-		MARK_PRICE_PRECISION
+		PRICE_PRECISION
 	);
 
 	console.log(

package/lib/accounts/pollingClearingHouseAccountSubscriber.d.ts

@@ -1,7 +1,6 @@
-/// <reference types="bn.js" />
 /// <reference types="node" />
 import { DataAndSlot, AccountToPoll, ClearingHouseAccountEvents, ClearingHouseAccountSubscriber, OraclesToPoll } from './types';
-import { BN, Program } from '@project-serum/anchor';
+import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { SpotMarketAccount, PerpMarketAccount, StateAccount, UserAccount } from '../types';
@@ -12,8 +11,8 @@ import { OracleClientCache } from '../oracles/oracleClientCache';
 export declare class PollingClearingHouseAccountSubscriber implements ClearingHouseAccountSubscriber {
     isSubscribed: boolean;
     program: Program;
-    perpMarketIndexes: BN[];
-    spotMarketIndexes: BN[];
+    perpMarketIndexes: number[];
+    spotMarketIndexes: number[];
     oracleInfos: OracleInfo[];
     oracleClientCache: OracleClientCache;
     eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
@@ -29,13 +28,13 @@ export declare class PollingClearingHouseAccountSubscriber implements ClearingHo
     private isSubscribing;
     private subscriptionPromise;
     private subscriptionPromiseResolver;
-    constructor(program: Program, accountLoader: BulkAccountLoader, perpMarketIndexes: BN[], spotMarketIndexes: BN[], oracleInfos: OracleInfo[]);
+    constructor(program: Program, accountLoader: BulkAccountLoader, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[]);
     subscribe(): Promise<boolean>;
     updateAccountsToPoll(): Promise<void>;
     updateMarketAccountsToPoll(): Promise<boolean>;
-    addMarketAccountToPoll(marketIndex: BN): Promise<boolean>;
+    addMarketAccountToPoll(marketIndex: number): Promise<boolean>;
     updateSpotMarketAccountsToPoll(): Promise<boolean>;
-    addSpotMarketAccountToPoll(marketIndex: BN): Promise<boolean>;
+    addSpotMarketAccountToPoll(marketIndex: number): Promise<boolean>;
     updateOraclesToPoll(): boolean;
     addOracleToPoll(oracleInfo: OracleInfo): boolean;
     getClearingHouseAccounts(): Promise<ClearingHouseAccounts>;
@@ -45,14 +44,14 @@ export declare class PollingClearingHouseAccountSubscriber implements ClearingHo
     fetch(): Promise<void>;
     didSubscriptionSucceed(): boolean;
     unsubscribe(): Promise<void>;
-    addSpotMarket(marketIndex: BN): Promise<boolean>;
-    addPerpMarket(marketIndex: BN): Promise<boolean>;
+    addSpotMarket(marketIndex: number): Promise<boolean>;
+    addPerpMarket(marketIndex: number): Promise<boolean>;
     addOracle(oracleInfo: OracleInfo): Promise<boolean>;
     assertIsSubscribed(): void;
     getStateAccountAndSlot(): DataAndSlot<StateAccount>;
-    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<PerpMarketAccount> | undefined;
+    getMarketAccountAndSlot(marketIndex: number): DataAndSlot<PerpMarketAccount> | undefined;
     getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[];
-    getSpotMarketAccountAndSlot(marketIndex: BN): DataAndSlot<SpotMarketAccount> | undefined;
+    getSpotMarketAccountAndSlot(marketIndex: number): DataAndSlot<SpotMarketAccount> | undefined;
     getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[];
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
 }

package/lib/accounts/pollingClearingHouseAccountSubscriber.js

@@ -79,7 +79,7 @@ class PollingClearingHouseAccountSubscriber {
             key: 'perpMarket',
             publicKey: marketPublicKey,
             eventType: 'perpMarketAccountUpdate',
-            mapKey: marketIndex.toNumber(),
+            mapKey: marketIndex,
         });
         return true;
     }
@@ -95,7 +95,7 @@ class PollingClearingHouseAccountSubscriber {
             key: 'spotMarket',
             publicKey: marketPublicKey,
             eventType: 'spotMarketAccountUpdate',
-            mapKey: marketIndex.toNumber(),
+            mapKey: marketIndex,
         });
         return true;
     }
@@ -254,13 +254,13 @@ class PollingClearingHouseAccountSubscriber {
         return this.state;
     }
     getMarketAccountAndSlot(marketIndex) {
-        return this.perpMarket.get(marketIndex.toNumber());
+        return this.perpMarket.get(marketIndex);
     }
     getMarketAccountsAndSlots() {
         return Array.from(this.perpMarket.values());
     }
     getSpotMarketAccountAndSlot(marketIndex) {
-        return this.spotMarket.get(marketIndex.toNumber());
+        return this.spotMarket.get(marketIndex);
     }
     getSpotMarketAccountsAndSlots() {
         return Array.from(this.spotMarket.values());

package/lib/accounts/types.d.ts

@@ -1,12 +1,10 @@
 /// <reference types="node" />
-/// <reference types="bn.js" />
 import { SpotMarketAccount, PerpMarketAccount, OracleSource, StateAccount, UserAccount, UserStatsAccount } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
 import { AccountInfo } from '@solana/spl-token';
 import { OracleInfo, OraclePriceData } from '..';
-import { BN } from '@project-serum/anchor';
 export interface AccountSubscriber<T> {
     dataAndSlot?: DataAndSlot<T>;
     subscribe(onChange: (data: T) => void): Promise<void>;
@@ -31,13 +29,13 @@ export interface ClearingHouseAccountSubscriber {
     subscribe(): Promise<boolean>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
-    addPerpMarket(marketIndex: BN): Promise<boolean>;
-    addSpotMarket(marketIndex: BN): Promise<boolean>;
+    addPerpMarket(marketIndex: number): Promise<boolean>;
+    addSpotMarket(marketIndex: number): Promise<boolean>;
     addOracle(oracleInfo: OracleInfo): Promise<boolean>;
     getStateAccountAndSlot(): DataAndSlot<StateAccount>;
-    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<PerpMarketAccount> | undefined;
+    getMarketAccountAndSlot(marketIndex: number): DataAndSlot<PerpMarketAccount> | undefined;
     getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[];
-    getSpotMarketAccountAndSlot(marketIndex: BN): DataAndSlot<SpotMarketAccount> | undefined;
+    getSpotMarketAccountAndSlot(marketIndex: number): DataAndSlot<SpotMarketAccount> | undefined;
     getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[];
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
 }

package/lib/accounts/webSocketClearingHouseAccountSubscriber.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="bn.js" />
 /// <reference types="node" />
 import { ClearingHouseAccountSubscriber, ClearingHouseAccountEvents, DataAndSlot } from './types';
 import { AccountSubscriber } from './types';
 import { SpotMarketAccount, PerpMarketAccount, StateAccount } from '../types';
-import { BN, Program } from '@project-serum/anchor';
+import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
@@ -12,8 +11,8 @@ import { OracleClientCache } from '../oracles/oracleClientCache';
 export declare class WebSocketClearingHouseAccountSubscriber implements ClearingHouseAccountSubscriber {
     isSubscribed: boolean;
     program: Program;
-    perpMarketIndexes: BN[];
-    spotMarketIndexes: BN[];
+    perpMarketIndexes: number[];
+    spotMarketIndexes: number[];
     oracleInfos: OracleInfo[];
     oracleClientCache: OracleClientCache;
     eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
@@ -24,12 +23,12 @@ export declare class WebSocketClearingHouseAccountSubscriber implements Clearing
     private isSubscribing;
     private subscriptionPromise;
     private subscriptionPromiseResolver;
-    constructor(program: Program, perpMarketIndexes: BN[], spotMarketIndexes: BN[], oracleInfos: OracleInfo[]);
+    constructor(program: Program, perpMarketIndexes: number[], spotMarketIndexes: number[], oracleInfos: OracleInfo[]);
     subscribe(): Promise<boolean>;
     subscribeToMarketAccounts(): Promise<boolean>;
-    subscribeToMarketAccount(marketIndex: BN): Promise<boolean>;
+    subscribeToMarketAccount(marketIndex: number): Promise<boolean>;
     subscribeToSpotMarketAccounts(): Promise<boolean>;
-    subscribeToSpotMarketAccount(marketIndex: BN): Promise<boolean>;
+    subscribeToSpotMarketAccount(marketIndex: number): Promise<boolean>;
     subscribeToOracles(): Promise<boolean>;
     subscribeToOracle(oracleInfo: OracleInfo): Promise<boolean>;
     unsubscribeFromMarketAccounts(): Promise<void>;
@@ -37,14 +36,14 @@ export declare class WebSocketClearingHouseAccountSubscriber implements Clearing
     unsubscribeFromOracles(): Promise<void>;
     fetch(): Promise<void>;
     unsubscribe(): Promise<void>;
-    addSpotMarket(marketIndex: BN): Promise<boolean>;
-    addPerpMarket(marketIndex: BN): Promise<boolean>;
+    addSpotMarket(marketIndex: number): Promise<boolean>;
+    addPerpMarket(marketIndex: number): Promise<boolean>;
     addOracle(oracleInfo: OracleInfo): Promise<boolean>;
     assertIsSubscribed(): void;
     getStateAccountAndSlot(): DataAndSlot<StateAccount>;
-    getMarketAccountAndSlot(marketIndex: BN): DataAndSlot<PerpMarketAccount> | undefined;
+    getMarketAccountAndSlot(marketIndex: number): DataAndSlot<PerpMarketAccount> | undefined;
     getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[];
-    getSpotMarketAccountAndSlot(marketIndex: BN): DataAndSlot<SpotMarketAccount> | undefined;
+    getSpotMarketAccountAndSlot(marketIndex: number): DataAndSlot<SpotMarketAccount> | undefined;
     getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[];
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
 }

package/lib/accounts/webSocketClearingHouseAccountSubscriber.js

@@ -65,7 +65,7 @@ class WebSocketClearingHouseAccountSubscriber {
             this.eventEmitter.emit('perpMarketAccountUpdate', data);
             this.eventEmitter.emit('update');
         });
-        this.perpMarketAccountSubscribers.set(marketIndex.toNumber(), accountSubscriber);
+        this.perpMarketAccountSubscribers.set(marketIndex, accountSubscriber);
         return true;
     }
     async subscribeToSpotMarketAccounts() {
@@ -81,7 +81,7 @@ class WebSocketClearingHouseAccountSubscriber {
             this.eventEmitter.emit('spotMarketAccountUpdate', data);
             this.eventEmitter.emit('update');
         });
-        this.spotMarketAccountSubscribers.set(marketIndex.toNumber(), accountSubscriber);
+        this.spotMarketAccountSubscribers.set(marketIndex, accountSubscriber);
         return true;
     }
     async subscribeToOracles() {
@@ -139,13 +139,13 @@ class WebSocketClearingHouseAccountSubscriber {
         this.isSubscribed = false;
     }
     async addSpotMarket(marketIndex) {
-        if (this.spotMarketAccountSubscribers.has(marketIndex.toNumber())) {
+        if (this.spotMarketAccountSubscribers.has(marketIndex)) {
             return true;
         }
         return this.subscribeToSpotMarketAccount(marketIndex);
     }
     async addPerpMarket(marketIndex) {
-        if (this.perpMarketAccountSubscribers.has(marketIndex.toNumber())) {
+        if (this.perpMarketAccountSubscribers.has(marketIndex)) {
             return true;
         }
         return this.subscribeToMarketAccount(marketIndex);
@@ -170,16 +170,14 @@ class WebSocketClearingHouseAccountSubscriber {
     }
     getMarketAccountAndSlot(marketIndex) {
         this.assertIsSubscribed();
-        return this.perpMarketAccountSubscribers.get(marketIndex.toNumber())
-            .dataAndSlot;
+        return this.perpMarketAccountSubscribers.get(marketIndex).dataAndSlot;
     }
     getMarketAccountsAndSlots() {
         return Array.from(this.perpMarketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
     }
     getSpotMarketAccountAndSlot(marketIndex) {
         this.assertIsSubscribed();
-        return this.spotMarketAccountSubscribers.get(marketIndex.toNumber())
-            .dataAndSlot;
+        return this.spotMarketAccountSubscribers.get(marketIndex).dataAndSlot;
     }
     getSpotMarketAccountsAndSlots() {
         return Array.from(this.spotMarketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);

package/lib/addresses/marketAddresses.d.ts

@@ -1,4 +1,2 @@
-/// <reference types="bn.js" />
 import { PublicKey } from '@solana/web3.js';
-import { BN } from '@project-serum/anchor';
-export declare function getMarketAddress(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
+export declare function getMarketAddress(programId: PublicKey, marketIndex: number): Promise<PublicKey>;

package/lib/addresses/pda.d.ts

@@ -7,11 +7,11 @@ export declare function getUserAccountPublicKeyAndNonce(programId: PublicKey, au
 export declare function getUserAccountPublicKey(programId: PublicKey, authority: PublicKey, userId?: number): Promise<PublicKey>;
 export declare function getUserAccountPublicKeySync(programId: PublicKey, authority: PublicKey, userId?: number): PublicKey;
 export declare function getUserStatsAccountPublicKey(programId: PublicKey, authority: PublicKey): PublicKey;
-export declare function getMarketPublicKey(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
-export declare function getSpotMarketPublicKey(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
-export declare function getSpotMarketVaultPublicKey(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
-export declare function getInsuranceFundVaultPublicKey(programId: PublicKey, marketIndex: BN): Promise<PublicKey>;
-export declare function getInsuranceFundStakeAccountPublicKey(programId: PublicKey, authority: PublicKey, marketIndex: BN): PublicKey;
+export declare function getMarketPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getSpotMarketPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getSpotMarketVaultPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getInsuranceFundVaultPublicKey(programId: PublicKey, marketIndex: number): Promise<PublicKey>;
+export declare function getInsuranceFundStakeAccountPublicKey(programId: PublicKey, authority: PublicKey, marketIndex: number): PublicKey;
 export declare function getClearingHouseSignerPublicKey(programId: PublicKey): PublicKey;
 export declare function getSerumOpenOrdersPublicKey(programId: PublicKey, market: PublicKey): PublicKey;
 export declare function getSerumSignerPublicKey(programId: PublicKey, market: PublicKey, nonce: BN): PublicKey;

package/lib/addresses/pda.js

@@ -63,28 +63,28 @@ exports.getUserStatsAccountPublicKey = getUserStatsAccountPublicKey;
 async function getMarketPublicKey(programId, marketIndex) {
     return (await anchor.web3.PublicKey.findProgramAddress([
         Buffer.from(anchor.utils.bytes.utf8.encode('market')),
-        marketIndex.toArrayLike(Buffer, 'le', 8),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId))[0];
 }
 exports.getMarketPublicKey = getMarketPublicKey;
 async function getSpotMarketPublicKey(programId, marketIndex) {
     return (await anchor.web3.PublicKey.findProgramAddress([
         Buffer.from(anchor.utils.bytes.utf8.encode('spot_market')),
-        marketIndex.toArrayLike(Buffer, 'le', 8),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId))[0];
 }
 exports.getSpotMarketPublicKey = getSpotMarketPublicKey;
 async function getSpotMarketVaultPublicKey(programId, marketIndex) {
     return (await anchor.web3.PublicKey.findProgramAddress([
         Buffer.from(anchor.utils.bytes.utf8.encode('spot_market_vault')),
-        marketIndex.toArrayLike(Buffer, 'le', 8),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId))[0];
 }
 exports.getSpotMarketVaultPublicKey = getSpotMarketVaultPublicKey;
 async function getInsuranceFundVaultPublicKey(programId, marketIndex) {
     return (await anchor.web3.PublicKey.findProgramAddress([
         Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_vault')),
-        marketIndex.toArrayLike(Buffer, 'le', 8),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId))[0];
 }
 exports.getInsuranceFundVaultPublicKey = getInsuranceFundVaultPublicKey;
@@ -92,7 +92,7 @@ function getInsuranceFundStakeAccountPublicKey(programId, authority, marketIndex
     return anchor.web3.PublicKey.findProgramAddressSync([
         Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_stake')),
         authority.toBuffer(),
-        marketIndex.toArrayLike(Buffer, 'le', 8),
+        new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
     ], programId)[0];
 }
 exports.getInsuranceFundStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey;

package/lib/admin.d.ts

@@ -6,24 +6,22 @@ import { ClearingHouse } from './clearingHouse';
 export declare class Admin extends ClearingHouse {
     initialize(usdcMint: PublicKey, adminControlsPrices: boolean): Promise<[TransactionSignature]>;
     initializeSpotMarket(mint: PublicKey, optimalUtilization: BN, optimalRate: BN, maxRate: BN, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: BN, maintenanceAssetWeight: BN, initialLiabilityWeight: BN, maintenanceLiabilityWeight: BN, imfFactor?: BN, liquidationFee?: BN): Promise<TransactionSignature>;
-    initializeSerumFulfillmentConfig(marketIndex: BN, serumMarket: PublicKey, serumProgram: PublicKey): Promise<TransactionSignature>;
+    initializeSerumFulfillmentConfig(marketIndex: number, serumMarket: PublicKey, serumProgram: PublicKey): Promise<TransactionSignature>;
     initializeMarket(priceOracle: PublicKey, baseAssetReserve: BN, quoteAssetReserve: BN, periodicity: BN, pegMultiplier?: BN, oracleSource?: OracleSource, marginRatioInitial?: number, marginRatioMaintenance?: number, liquidationFee?: BN): Promise<TransactionSignature>;
-    moveAmmPrice(marketIndex: BN, baseAssetReserve: BN, quoteAssetReserve: BN, sqrtK?: BN): Promise<TransactionSignature>;
-    updateK(sqrtK: BN, marketIndex: BN): Promise<TransactionSignature>;
-    updateConcentrationScale(marketIndex: BN, concentrationScale: BN): Promise<TransactionSignature>;
-    moveAmmToPrice(perpMarketIndex: BN, targetPrice: BN): Promise<TransactionSignature>;
-    repegAmmCurve(newPeg: BN, marketIndex: BN): Promise<TransactionSignature>;
-    updateAmmOracleTwap(marketIndex: BN): Promise<TransactionSignature>;
-    resetAmmOracleTwap(marketIndex: BN): Promise<TransactionSignature>;
-    withdrawFromInsuranceVault(amount: BN, recipient: PublicKey): Promise<TransactionSignature>;
-    withdrawFromMarketToInsuranceVault(marketIndex: BN, amount: BN, recipient: PublicKey): Promise<TransactionSignature>;
-    withdrawFromInsuranceVaultToMarket(marketIndex: BN, amount: BN): Promise<TransactionSignature>;
+    moveAmmPrice(marketIndex: number, baseAssetReserve: BN, quoteAssetReserve: BN, sqrtK?: BN): Promise<TransactionSignature>;
+    updateK(sqrtK: BN, marketIndex: number): Promise<TransactionSignature>;
+    updateConcentrationScale(marketIndex: number, concentrationScale: BN): Promise<TransactionSignature>;
+    moveAmmToPrice(perpMarketIndex: number, targetPrice: BN): Promise<TransactionSignature>;
+    repegAmmCurve(newPeg: BN, marketIndex: number): Promise<TransactionSignature>;
+    updateAmmOracleTwap(marketIndex: number): Promise<TransactionSignature>;
+    resetAmmOracleTwap(marketIndex: number): Promise<TransactionSignature>;
+    depositIntoMarketFeePool(marketIndex: number, amount: BN, sourceVault: PublicKey): Promise<TransactionSignature>;
     updateAdmin(admin: PublicKey): Promise<TransactionSignature>;
-    updateCurveUpdateIntensity(marketIndex: BN, curveUpdateIntensity: number): Promise<TransactionSignature>;
-    updateMarginRatio(marketIndex: BN, marginRatioInitial: number, marginRatioMaintenance: number): Promise<TransactionSignature>;
-    updateMarketBaseSpread(marketIndex: BN, baseSpread: number): Promise<TransactionSignature>;
-    updateAmmJitIntensity(marketIndex: BN, ammJitIntensity: number): Promise<TransactionSignature>;
-    updateMarketMaxSpread(marketIndex: BN, maxSpread: number): Promise<TransactionSignature>;
+    updateCurveUpdateIntensity(marketIndex: number, curveUpdateIntensity: number): Promise<TransactionSignature>;
+    updateMarginRatio(marketIndex: number, marginRatioInitial: number, marginRatioMaintenance: number): Promise<TransactionSignature>;
+    updateMarketBaseSpread(marketIndex: number, baseSpread: number): Promise<TransactionSignature>;
+    updateAmmJitIntensity(marketIndex: number, ammJitIntensity: number): Promise<TransactionSignature>;
+    updateMarketMaxSpread(marketIndex: number, maxSpread: number): Promise<TransactionSignature>;
     updatePartialLiquidationClosePercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
     updatePartialLiquidationPenaltyPercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
     updateFullLiquidationPenaltyPercentage(numerator: BN, denominator: BN): Promise<TransactionSignature>;
@@ -32,15 +30,15 @@ export declare class Admin extends ClearingHouse {
     updatePerpFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;
     updateSpotFeeStructure(feeStructure: FeeStructure): Promise<TransactionSignature>;
     updateOracleGuardRails(oracleGuardRails: OracleGuardRails): Promise<TransactionSignature>;
-    updateWithdrawGuardThreshold(marketIndex: BN, withdrawGuardThreshold: BN): Promise<TransactionSignature>;
-    updateSpotMarketIfFactor(marketIndex: BN, userIfFactor: BN, totalIfFactor: BN): Promise<TransactionSignature>;
-    updateSpotMarketRevenueSettlePeriod(marketIndex: BN, revenueSettlePeriod: BN): Promise<TransactionSignature>;
-    updateInsuranceWithdrawEscrowPeriod(marketIndex: BN, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionSignature>;
-    updateLpCooldownTime(marketIndex: BN, cooldownTime: BN): Promise<TransactionSignature>;
-    updateMarketOracle(marketIndex: BN, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
-    updateMarketMinimumQuoteAssetTradeSize(marketIndex: BN, minimumTradeSize: BN): Promise<TransactionSignature>;
-    updateMarketBaseAssetAmountStepSize(marketIndex: BN, stepSize: BN): Promise<TransactionSignature>;
-    updateMarketExpiry(perpMarketIndex: BN, expiryTs: BN): Promise<TransactionSignature>;
+    updateWithdrawGuardThreshold(marketIndex: number, withdrawGuardThreshold: BN): Promise<TransactionSignature>;
+    updateSpotMarketIfFactor(marketIndex: number, userIfFactor: BN, totalIfFactor: BN): Promise<TransactionSignature>;
+    updateSpotMarketRevenueSettlePeriod(marketIndex: number, revenueSettlePeriod: BN): Promise<TransactionSignature>;
+    updateInsuranceWithdrawEscrowPeriod(marketIndex: number, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionSignature>;
+    updateLpCooldownTime(marketIndex: number, cooldownTime: BN): Promise<TransactionSignature>;
+    updateMarketOracle(marketIndex: number, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;
+    updateMarketMinimumQuoteAssetTradeSize(marketIndex: number, minimumTradeSize: BN): Promise<TransactionSignature>;
+    updateMarketBaseAssetAmountStepSize(marketIndex: number, stepSize: BN): Promise<TransactionSignature>;
+    updateMarketExpiry(perpMarketIndex: number, expiryTs: BN): Promise<TransactionSignature>;
     updateWhitelistMint(whitelistMint?: PublicKey): Promise<TransactionSignature>;
     updateDiscountMint(discountMint: PublicKey): Promise<TransactionSignature>;
     updateMaxDeposit(maxDeposit: BN): Promise<TransactionSignature>;
@@ -49,7 +47,8 @@ export declare class Admin extends ClearingHouse {
     disableAdminControlsPrices(): Promise<TransactionSignature>;
     updatePerpAuctionDuration(minDuration: BN | number): Promise<TransactionSignature>;
     updateSpotAuctionDuration(defaultAuctionDuration: number): Promise<TransactionSignature>;
-    updateMaxBaseAssetAmountRatio(marketIndex: BN, maxBaseAssetAmountRatio: number): Promise<TransactionSignature>;
-    updateMaxSlippageRatio(marketIndex: BN, maxSlippageRatio: number): Promise<TransactionSignature>;
-    updateMarketMaxImbalances(marketIndex: BN, unrealizedMaxImbalance: BN, maxRevenueWithdrawPerPeriod: BN, quoteMaxInsurance: BN): Promise<TransactionSignature>;
+    updateMaxBaseAssetAmountRatio(marketIndex: number, maxBaseAssetAmountRatio: number): Promise<TransactionSignature>;
+    updateMaxSlippageRatio(marketIndex: number, maxSlippageRatio: number): Promise<TransactionSignature>;
+    updateMarketMaxImbalances(marketIndex: number, unrealizedMaxImbalance: BN, maxRevenueWithdrawPerPeriod: BN, quoteMaxInsurance: BN): Promise<TransactionSignature>;
+    updateSerumVault(srmVault: PublicKey): Promise<TransactionSignature>;
 }

package/lib/admin.js

@@ -42,14 +42,12 @@ class Admin extends clearingHouse_1.ClearingHouse {
             throw new Error('Clearing house already initialized');
         }
         const [clearingHouseStatePublicKey] = await (0, pda_1.getClearingHouseStateAccountPublicKeyAndNonce)(this.program.programId);
-        const [insuranceVaultPublicKey] = await web3_js_1.PublicKey.findProgramAddress([Buffer.from(anchor.utils.bytes.utf8.encode('insurance_vault'))], this.program.programId);
         const initializeTx = await this.program.transaction.initialize(adminControlsPrices, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: clearingHouseStatePublicKey,
                 quoteAssetMint: usdcMint,
                 rent: web3_js_1.SYSVAR_RENT_PUBKEY,
-                insuranceVault: insuranceVaultPublicKey,
                 clearingHouseSigner: this.getSignerPublicKey(),
                 systemProgram: anchor.web3.SystemProgram.programId,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
@@ -207,46 +205,14 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
-    async withdrawFromInsuranceVault(amount, recipient) {
-        const state = await this.getStateAccount();
+    async depositIntoMarketFeePool(marketIndex, amount, sourceVault) {
         const spotMarket = this.getQuoteSpotMarketAccount();
-        return await this.program.rpc.withdrawFromInsuranceVault(amount, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                spotMarket: spotMarket.pubkey,
-                insuranceVault: state.insuranceVault,
-                clearingHouseSigner: this.getSignerPublicKey(),
-                recipient: recipient,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
-    }
-    async withdrawFromMarketToInsuranceVault(marketIndex, amount, recipient) {
-        const marketPublicKey = await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex);
-        const spotMarket = this.getQuoteSpotMarketAccount();
-        return await this.program.rpc.withdrawFromMarketToInsuranceVault(amount, {
-            accounts: {
-                admin: this.wallet.publicKey,
-                state: await this.getStatePublicKey(),
-                market: marketPublicKey,
-                spotMarket: spotMarket.pubkey,
-                spotMarketVault: spotMarket.vault,
-                clearingHouseSigner: this.getSignerPublicKey(),
-                recipient: recipient,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-            },
-        });
-    }
-    async withdrawFromInsuranceVaultToMarket(marketIndex, amount) {
-        const state = await this.getStateAccount();
-        const spotMarket = this.getQuoteSpotMarketAccount();
-        return await this.program.rpc.withdrawFromInsuranceVaultToMarket(amount, {
+        return await this.program.rpc.depositIntoMarketFeePool(amount, {
             accounts: {
                 admin: this.wallet.publicKey,
                 state: await this.getStatePublicKey(),
                 market: await (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex),
-                insuranceVault: state.insuranceVault,
+                sourceVault,
                 clearingHouseSigner: this.getSignerPublicKey(),
                 quoteSpotMarket: spotMarket.pubkey,
                 spotMarketVault: spotMarket.vault,
@@ -545,5 +511,14 @@ class Admin extends clearingHouse_1.ClearingHouse {
             },
         });
     }
+    async updateSerumVault(srmVault) {
+        return await this.program.rpc.updateSerumVault({
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                srmVault: srmVault,
+            },
+        });
+    }
 }
 exports.Admin = Admin;