@drift-labs/sdk 0.1.18-orders.0 → 0.1.18-orders.4

package/src/accounts/pollingUserAccountSubscriber.ts

@@ -0,0 +1,186 @@
+import {
+	AccountToPoll,
+	NotSubscribedError,
+	UserAccountEvents,
+	UserAccountSubscriber,
+} from './types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import {
+	getUserAccountPublicKey,
+	getUserOrdersAccountPublicKey,
+} from '../addresses';
+import { UserAccount, UserOrdersAccount, UserPositionsAccount } from '../types';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { capitalize } from './utils';
+import { ClearingHouseConfigType } from '../factory/clearingHouse';
+
+export class PollingUserAccountSubscriber implements UserAccountSubscriber {
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
+	authority: PublicKey;
+
+	accountLoader: BulkAccountLoader;
+	accountsToPoll = new Map<string, AccountToPoll>();
+	errorCallbackId?: string;
+
+	user?: UserAccount;
+	userPositions?: UserPositionsAccount;
+	userOrders?: UserOrdersAccount;
+
+	type: ClearingHouseConfigType = 'polling';
+
+	public constructor(
+		program: Program,
+		authority: PublicKey,
+		accountLoader: BulkAccountLoader
+	) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.authority = authority;
+		this.accountLoader = accountLoader;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	async subscribe(): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		await this.addToAccountLoader();
+		await this.fetchIfUnloaded();
+		this.eventEmitter.emit('update');
+
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async addToAccountLoader(): Promise<void> {
+		if (this.accountsToPoll.size > 0) {
+			return;
+		}
+
+		const userPublicKey = await getUserAccountPublicKey(
+			this.program.programId,
+			this.authority
+		);
+
+		const userAccount = (await this.program.account.user.fetch(
+			userPublicKey
+		)) as UserAccount;
+
+		this.accountsToPoll.set(userPublicKey.toString(), {
+			key: 'user',
+			publicKey: userPublicKey,
+			eventType: 'userAccountData',
+		});
+
+		this.accountsToPoll.set(userAccount.positions.toString(), {
+			key: 'userPositions',
+			publicKey: userAccount.positions,
+			eventType: 'userPositionsData',
+		});
+
+		const userOrdersPublicKey = await getUserOrdersAccountPublicKey(
+			this.program.programId,
+			userPublicKey
+		);
+
+		this.accountsToPoll.set(userOrdersPublicKey.toString(), {
+			key: 'userOrders',
+			publicKey: userOrdersPublicKey,
+			eventType: 'userOrdersData',
+		});
+
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			accountToPoll.callbackId = this.accountLoader.addAccount(
+				accountToPoll.publicKey,
+				(buffer) => {
+					const account = this.program.account[
+						accountToPoll.key
+					].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
+					this[accountToPoll.key] = account;
+					// @ts-ignore
+					this.eventEmitter.emit(accountToPoll.eventType, account);
+					this.eventEmitter.emit('update');
+				}
+			);
+		}
+
+		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+			this.eventEmitter.emit('error', error);
+		});
+	}
+
+	async fetchIfUnloaded(): Promise<void> {
+		let shouldFetch = false;
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			if (this[accountToPoll.key] === undefined) {
+				shouldFetch = true;
+				break;
+			}
+		}
+
+		if (shouldFetch) {
+			await this.fetch();
+		}
+	}
+
+	async fetch(): Promise<void> {
+		await this.accountLoader.load();
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			const buffer = this.accountLoader.getAccountData(accountToPoll.publicKey);
+			if (buffer) {
+				this[accountToPoll.key] = this.program.account[
+					accountToPoll.key
+				].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
+			}
+		}
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			this.accountLoader.removeAccount(
+				accountToPoll.publicKey,
+				accountToPoll.callbackId
+			);
+		}
+
+		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+		this.errorCallbackId = undefined;
+
+		this.accountsToPoll.clear();
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getUserAccount(): UserAccount {
+		this.assertIsSubscribed();
+		return this.user;
+	}
+
+	public getUserPositionsAccount(): UserPositionsAccount {
+		this.assertIsSubscribed();
+		return this.userPositions;
+	}
+
+	public getUserOrdersAccount(): UserOrdersAccount {
+		this.assertIsSubscribed();
+		return this.userOrders;
+	}
+}

package/src/accounts/types.ts

@@ -1,6 +1,6 @@
 import {
-	CurveHistoryAccount,
 	DepositHistoryAccount,
+	ExtendedCurveHistoryAccount,
 	FundingPaymentHistoryAccount,
 	FundingRateHistoryAccount,
 	LiquidationHistoryAccount,
@@ -15,12 +15,15 @@ import {
 } 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 { ClearingHouseConfigType, ClearingHouseUserConfigType } from '..';
 
 export interface AccountSubscriber<T> {
 	data?: T;
 	subscribe(onChange: (data: T) => void): Promise<void>;
 	fetch(): Promise<void>;
-	unsubscribe(): void;
+	unsubscribe(): Promise<void>;
 }
 
 export class NotSubscribedError extends Error {
@@ -37,10 +40,11 @@ export interface ClearingHouseAccountEvents {
 	tradeHistoryAccountUpdate: (payload: TradeHistoryAccount) => void;
 	liquidationHistoryAccountUpdate: (payload: LiquidationHistoryAccount) => void;
 	depositHistoryAccountUpdate: (payload: DepositHistoryAccount) => void;
-	curveHistoryAccountUpdate: (payload: CurveHistoryAccount) => void;
+	curveHistoryAccountUpdate: (payload: ExtendedCurveHistoryAccount) => void;
 	orderHistoryAccountUpdate: (payload: OrderHistoryAccount) => void;
 	orderStateAccountUpdate: (payload: OrderStateAccount) => void;
 	update: void;
+	error: (e: Error) => void;
 }
 
 export type ClearingHouseAccountTypes =
@@ -70,37 +74,12 @@ export interface ClearingHouseAccountSubscriber {
 	getDepositHistoryAccount(): DepositHistoryAccount;
 	getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
 	getFundingRateHistoryAccount(): FundingRateHistoryAccount;
-	getCurveHistoryAccount(): CurveHistoryAccount;
+	getCurveHistoryAccount(): ExtendedCurveHistoryAccount;
 	getLiquidationHistoryAccount(): LiquidationHistoryAccount;
 	getOrderStateAccount(): OrderStateAccount;
 	getOrderHistoryAccount(): OrderHistoryAccount;
-}
-
-export interface HistoryAccountEvents {
-	fundingPaymentHistoryAccountUpdate: (
-		payload: FundingPaymentHistoryAccount
-	) => void;
-	fundingRateHistoryAccountUpdate: (payload: FundingRateHistoryAccount) => void;
-	tradeHistoryAccountUpdate: (payload: TradeHistoryAccount) => void;
-	liquidationHistoryAccountUpdate: (payload: LiquidationHistoryAccount) => void;
-	depositHistoryAccountUpdate: (payload: DepositHistoryAccount) => void;
-	curveHistoryAccountUpdate: (payload: CurveHistoryAccount) => void;
-	update: void;
-}
-
-export interface HistoryAccountSubscriber {
-	eventEmitter: StrictEventEmitter<EventEmitter, HistoryAccountEvents>;
-	isSubscribed: boolean;
-
-	subscribe(): Promise<boolean>;
-	unsubscribe(): Promise<void>;
 
-	getTradeHistoryAccount(): TradeHistoryAccount;
-	getDepositHistoryAccount(): DepositHistoryAccount;
-	getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
-	getFundingRateHistoryAccount(): FundingRateHistoryAccount;
-	getCurveHistoryAccount(): CurveHistoryAccount;
-	getLiquidationHistoryAccount(): LiquidationHistoryAccount;
+	type: ClearingHouseConfigType;
 }
 
 export interface UserAccountEvents {
@@ -108,6 +87,7 @@ export interface UserAccountEvents {
 	userPositionsData: (payload: UserPositionsAccount) => void;
 	userOrdersData: (payload: UserOrdersAccount) => void;
 	update: void;
+	error: (e: Error) => void;
 }
 
 export interface UserAccountSubscriber {
@@ -121,4 +101,34 @@ export interface UserAccountSubscriber {
 	getUserAccount(): UserAccount;
 	getUserPositionsAccount(): UserPositionsAccount;
 	getUserOrdersAccount(): UserOrdersAccount;
+	type: ClearingHouseUserConfigType;
 }
+
+export interface TokenAccountEvents {
+	tokenAccountUpdate: (payload: AccountInfo) => void;
+	update: void;
+	error: (e: Error) => void;
+}
+
+export interface TokenAccountSubscriber {
+	eventEmitter: StrictEventEmitter<EventEmitter, TokenAccountEvents>;
+	isSubscribed: boolean;
+
+	subscribe(): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	getTokenAccount(): AccountInfo;
+}
+
+export type AccountToPoll = {
+	key: string;
+	publicKey: PublicKey;
+	eventType: string;
+	callbackId?: string;
+};
+
+export type AccountData = {
+	slot: number;
+	buffer: Buffer | undefined;
+};

package/src/accounts/utils.ts

@@ -0,0 +1,3 @@
+export function capitalize(value: string): string {
+	return value[0].toUpperCase() + value.slice(1);
+}

package/src/accounts/webSocketAccountSubscriber.ts

@@ -1,13 +1,17 @@
-import { AccountSubscriber } from './types';
+import { AccountData, AccountSubscriber } from './types';
 import { Program } from '@project-serum/anchor';
-import { PublicKey } from '@solana/web3.js';
+import { AccountInfo, Context, PublicKey } from '@solana/web3.js';
+import { capitalize } from './utils';
+import * as Buffer from 'buffer';
 
 export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 	data?: T;
+	accountData?: AccountData;
 	accountName: string;
 	program: Program;
 	accountPublicKey: PublicKey;
 	onChange: (data: T) => void;
+	listenerId?: number;
 
 	public constructor(
 		accountName: string,
@@ -20,32 +24,78 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 	}
 
 	async subscribe(onChange: (data: T) => void): Promise<void> {
+		if (this.listenerId) {
+			return;
+		}
+
 		this.onChange = onChange;
 		await this.fetch();
 
-		this.program.account[this.accountName]
-			.subscribe(this.accountPublicKey, this.program.provider.opts.commitment)
-			.on('change', async (data: T) => {
-				this.data = data;
-				this.onChange(data);
-			});
+		this.listenerId = this.program.provider.connection.onAccountChange(
+			this.accountPublicKey,
+			(accountInfo, context) => {
+				this.handleRpcResponse(context, accountInfo);
+			},
+			this.program.provider.opts.commitment
+		);
 	}
 
 	async fetch(): Promise<void> {
-		const newData = (await this.program.account[this.accountName].fetch(
-			this.accountPublicKey
-		)) as T;
+		const rpcResponse =
+			await this.program.provider.connection.getAccountInfoAndContext(
+				this.accountPublicKey,
+				this.program.provider.opts.commitment
+			);
+		this.handleRpcResponse(rpcResponse.context, rpcResponse?.value);
+	}
+
+	handleRpcResponse(context: Context, accountInfo?: AccountInfo<Buffer>): void {
+		const newSlot = context.slot;
+		let newBuffer: Buffer | undefined = undefined;
+		if (accountInfo) {
+			newBuffer = accountInfo.data;
+		}
 
-		// if data has changed trigger update
-		if (JSON.stringify(newData) !== JSON.stringify(this.data)) {
-			this.data = newData;
+		if (!this.accountData) {
+			this.accountData = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			if (newBuffer) {
+				this.data = this.program.account[
+					this.accountName
+				].coder.accounts.decode(capitalize(this.accountName), newBuffer);
+				this.onChange(this.data);
+			}
+			return;
+		}
+
+		if (newSlot <= this.accountData.slot) {
+			return;
+		}
+
+		const oldBuffer = this.accountData.buffer;
+		if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+			this.accountData = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			this.data = this.program.account[this.accountName].coder.accounts.decode(
+				capitalize(this.accountName),
+				newBuffer
+			);
 			this.onChange(this.data);
 		}
 	}
 
 	unsubscribe(): Promise<void> {
-		return this.program.account[this.accountName].unsubscribe(
-			this.accountPublicKey
-		);
+		if (this.listenerId) {
+			const promise =
+				this.program.provider.connection.removeAccountChangeListener(
+					this.listenerId
+				);
+			this.listenerId = undefined;
+			return promise;
+		}
 	}
 }

package/src/accounts/{defaultClearingHouseAccountSubscriber.ts → webSocketClearingHouseAccountSubscriber.ts}

@@ -5,8 +5,8 @@ import {
 } from './types';
 import { AccountSubscriber, NotSubscribedError } from './types';
 import {
-	CurveHistoryAccount,
 	DepositHistoryAccount,
+	ExtendedCurveHistoryAccount,
 	FundingPaymentHistoryAccount,
 	FundingRateHistoryAccount,
 	LiquidationHistoryAccount,
@@ -21,8 +21,9 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { getClearingHouseStateAccountPublicKey } from '../addresses';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+import { ClearingHouseConfigType } from '../factory/clearingHouse';
 
-export class DefaultClearingHouseAccountSubscriber
+export class WebSocketClearingHouseAccountSubscriber
 	implements ClearingHouseAccountSubscriber
 {
 	isSubscribed: boolean;
@@ -34,13 +35,15 @@ export class DefaultClearingHouseAccountSubscriber
 	depositHistoryAccountSubscriber?: AccountSubscriber<DepositHistoryAccount>;
 	fundingPaymentHistoryAccountSubscriber?: AccountSubscriber<FundingPaymentHistoryAccount>;
 	fundingRateHistoryAccountSubscriber?: AccountSubscriber<FundingRateHistoryAccount>;
-	curveHistoryAccountSubscriber?: AccountSubscriber<CurveHistoryAccount>;
+	curveHistoryAccountSubscriber?: AccountSubscriber<ExtendedCurveHistoryAccount>;
 	liquidationHistoryAccountSubscriber?: AccountSubscriber<LiquidationHistoryAccount>;
 	orderStateAccountSubscriber?: AccountSubscriber<OrderStateAccount>;
 	orderHistoryAccountSubscriber?: AccountSubscriber<OrderHistoryAccount>;
 
 	optionalExtraSubscriptions: ClearingHouseAccountTypes[] = [];
 
+	type: ClearingHouseConfigType = 'websocket';
+
 	private isSubscribing = false;
 	private subscriptionPromise: Promise<boolean>;
 	private subscriptionPromiseResolver: (val: boolean) => void;
@@ -145,9 +148,9 @@ export class DefaultClearingHouseAccountSubscriber
 		);
 
 		this.curveHistoryAccountSubscriber = new WebSocketAccountSubscriber(
-			'curveHistory',
+			'extendedCurveHistory',
 			this.program,
-			state.curveHistory
+			state.extendedCurveHistory
 		);
 
 		this.orderHistoryAccountSubscriber = new WebSocketAccountSubscriber(
@@ -343,7 +346,7 @@ export class DefaultClearingHouseAccountSubscriber
 		return this.fundingRateHistoryAccountSubscriber.data;
 	}
 
-	public getCurveHistoryAccount(): CurveHistoryAccount {
+	public getCurveHistoryAccount(): ExtendedCurveHistoryAccount {
 		this.assertIsSubscribed();
 		this.assertOptionalIsSubscribed('curveHistoryAccount');
 		return this.curveHistoryAccountSubscriber.data;

package/src/accounts/{defaultUserAccountSubscriber.ts → webSocketUserAccountSubscriber.ts}

@@ -14,8 +14,9 @@ import {
 } from '../addresses';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
 import { UserAccount, UserOrdersAccount, UserPositionsAccount } from '../types';
+import { ClearingHouseConfigType } from '../factory/clearingHouse';
 
-export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
+export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 	isSubscribed: boolean;
 	program: Program;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
@@ -25,6 +26,8 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 	userPositionsAccountSubscriber: AccountSubscriber<UserPositionsAccount>;
 	userOrdersAccountSubscriber: AccountSubscriber<UserOrdersAccount>;
 
+	type: ClearingHouseConfigType = 'websocket';
+
 	public constructor(program: Program, authority: PublicKey) {
 		this.isSubscribed = false;
 		this.program = program;
@@ -67,7 +70,7 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 
 		const userOrdersPublicKey = await getUserOrdersAccountPublicKey(
 			this.program.programId,
-			this.authority
+			userPublicKey
 		);
 
 		this.userOrdersAccountSubscriber = new WebSocketAccountSubscriber(
@@ -100,9 +103,11 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 			return;
 		}
 
-		this.userDataAccountSubscriber.unsubscribe();
-		this.userPositionsAccountSubscriber.unsubscribe();
-		this.userOrdersAccountSubscriber.unsubscribe();
+		await Promise.all([
+			this.userDataAccountSubscriber.unsubscribe(),
+			this.userPositionsAccountSubscriber.unsubscribe(),
+			await this.userOrdersAccountSubscriber.unsubscribe(),
+		]);
 
 		this.isSubscribed = false;
 	}

package/src/addresses.ts

@@ -50,12 +50,12 @@ export async function getUserAccountPublicKey(
 
 export async function getUserOrdersAccountPublicKeyAndNonce(
 	programId: PublicKey,
-	authority: PublicKey
+	userAccount: PublicKey
 ): Promise<[PublicKey, number]> {
 	return anchor.web3.PublicKey.findProgramAddress(
 		[
 			Buffer.from(anchor.utils.bytes.utf8.encode('user_orders')),
-			authority.toBuffer(),
+			userAccount.toBuffer(),
 		],
 		programId
 	);
@@ -63,7 +63,9 @@ export async function getUserOrdersAccountPublicKeyAndNonce(
 
 export async function getUserOrdersAccountPublicKey(
 	programId: PublicKey,
-	authority: PublicKey
+	userAccount: PublicKey
 ): Promise<PublicKey> {
-	return (await getUserOrdersAccountPublicKeyAndNonce(programId, authority))[0];
+	return (
+		await getUserOrdersAccountPublicKeyAndNonce(programId, userAccount)
+	)[0];
 }

package/src/admin.ts

@@ -12,7 +12,7 @@ import {
 	OracleSource,
 	OrderFillerRewardStructure,
 } from './types';
-import { BN, Idl, Program, Provider } from '@project-serum/anchor';
+import { BN, Provider } from '@project-serum/anchor';
 import * as anchor from '@project-serum/anchor';
 import {
 	getClearingHouseStateAccountPublicKey,
@@ -22,11 +22,12 @@ import {
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { ClearingHouse } from './clearingHouse';
 import { PEG_PRECISION } from './constants/numericConstants';
-import clearingHouseIDL from './idl/clearing_house.json';
-import { DefaultClearingHouseAccountSubscriber } from './accounts/defaultClearingHouseAccountSubscriber';
-import { DefaultTxSender } from './tx/defaultTxSender';
 import { calculateTargetPriceTrade } from './math/trade';
 import { calculateAmmReservesAfterSwap, getSwapDirection } from './math/amm';
+import {
+	getAdmin,
+	getWebSocketClearingHouseConfig,
+} from './factory/clearingHouse';
 
 export class Admin extends ClearingHouse {
 	public static from(
@@ -35,24 +36,13 @@ export class Admin extends ClearingHouse {
 		clearingHouseProgramId: PublicKey,
 		opts: ConfirmOptions = Provider.defaultOptions()
 	): Admin {
-		const provider = new Provider(connection, wallet, opts);
-		const program = new Program(
-			clearingHouseIDL as Idl,
-			clearingHouseProgramId,
-			provider
-		);
-		const accountSubscriber = new DefaultClearingHouseAccountSubscriber(
-			program
-		);
-		const txSender = new DefaultTxSender(provider);
-		return new Admin(
+		const config = getWebSocketClearingHouseConfig(
 			connection,
 			wallet,
-			program,
-			accountSubscriber,
-			txSender,
+			clearingHouseProgramId,
 			opts
 		);
+		return getAdmin(config);
 	}
 
 	public async initialize(
@@ -165,7 +155,7 @@ export class Admin extends ClearingHouse {
 					await this.program.account.depositHistory.createInstruction(
 						depositHistory
 					),
-					await this.program.account.curveHistory.createInstruction(
+					await this.program.account.extendedCurveHistory.createInstruction(
 						curveHistory
 					),
 				],
@@ -275,13 +265,38 @@ export class Admin extends ClearingHouse {
 		marketIndex: BN
 	): Promise<TransactionSignature> {
 		const state = this.getStateAccount();
+		const markets = this.getMarketsAccount();
+		const marketData = markets.markets[marketIndex.toNumber()];
+		const ammData = marketData.amm;
+
 		return await this.program.rpc.updateK(sqrtK, marketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				admin: this.wallet.publicKey,
 				markets: state.markets,
+				curveHistory: state.extendedCurveHistory,
+				oracle: ammData.oracle,
+			},
+		});
+	}
+
+	public async updateCurveHistory(): Promise<TransactionSignature> {
+		const extendedCurveHistory = anchor.web3.Keypair.generate();
+
+		const state = this.getStateAccount();
+		return await this.program.rpc.updateCurveHistory({
+			accounts: {
+				state: await this.getStatePublicKey(),
+				admin: this.wallet.publicKey,
 				curveHistory: state.curveHistory,
+				extendedCurveHistory: extendedCurveHistory.publicKey,
 			},
+			instructions: [
+				await this.program.account.extendedCurveHistory.createInstruction(
+					extendedCurveHistory
+				),
+			],
+			signers: [extendedCurveHistory],
 		});
 	}
 
@@ -334,7 +349,45 @@ export class Admin extends ClearingHouse {
 				admin: this.wallet.publicKey,
 				oracle: ammData.oracle,
 				markets: state.markets,
-				curveHistory: state.curveHistory,
+				curveHistory: state.extendedCurveHistory,
+			},
+		});
+	}
+
+	public async updateAmmOracleTwap(
+		marketIndex: BN
+	): Promise<TransactionSignature> {
+		const state = this.getStateAccount();
+		const markets = this.getMarketsAccount();
+		const marketData = markets.markets[marketIndex.toNumber()];
+		const ammData = marketData.amm;
+
+		return await this.program.rpc.updateAmmOracleTwap(marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				admin: this.wallet.publicKey,
+				oracle: ammData.oracle,
+				markets: state.markets,
+				curveHistory: state.extendedCurveHistory,
+			},
+		});
+	}
+
+	public async resetAmmOracleTwap(
+		marketIndex: BN
+	): Promise<TransactionSignature> {
+		const state = this.getStateAccount();
+		const markets = this.getMarketsAccount();
+		const marketData = markets.markets[marketIndex.toNumber()];
+		const ammData = marketData.amm;
+
+		return await this.program.rpc.resetAmmOracleTwap(marketIndex, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				admin: this.wallet.publicKey,
+				oracle: ammData.oracle,
+				markets: state.markets,
+				curveHistory: state.extendedCurveHistory,
 			},
 		});
 	}