@drift-labs/sdk 0.2.0-master.22 → 0.2.0-master.25

package/src/clearingHouse.ts

@@ -39,7 +39,9 @@ import { TokenFaucet } from './tokenFaucet';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import {
+	getClearingHouseSignerPublicKey,
 	getClearingHouseStateAccountPublicKey,
+	getInsuranceFundStakeAccountPublicKey,
 	getMarketPublicKey,
 	getUserAccountPublicKey,
 	getUserAccountPublicKeySync,
@@ -259,6 +261,17 @@ export class ClearingHouse {
 		return this.statePublicKey;
 	}
 
+	signerPublicKey?: PublicKey;
+	public getSignerPublicKey(): PublicKey {
+		if (this.signerPublicKey) {
+			return this.signerPublicKey;
+		}
+		this.signerPublicKey = getClearingHouseSignerPublicKey(
+			this.program.programId
+		);
+		return this.signerPublicKey;
+	}
+
 	public getStateAccount(): StateAccount {
 		return this.accountSubscriber.getStateAccountAndSlot().data;
 	}
@@ -1063,7 +1076,7 @@ export class ClearingHouse {
 					state: await this.getStatePublicKey(),
 					bank: bank.pubkey,
 					bankVault: bank.vault,
-					bankVaultAuthority: bank.vaultAuthority,
+					clearingHouseSigner: this.getSignerPublicKey(),
 					user: userAccountPublicKey,
 					userStats: this.getUserStatsAccountPublicKey(),
 					userTokenAccount: userTokenAccount,
@@ -2175,6 +2188,7 @@ export class ClearingHouse {
 	public async resolvePerpBankruptcy(
 		userAccountPublicKey: PublicKey,
 		userAccount: UserAccount,
+		bankIndex: BN,
 		marketIndex: BN
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.txSender.send(
@@ -2182,6 +2196,7 @@ export class ClearingHouse {
 				await this.getResolvePerpBankruptcyIx(
 					userAccountPublicKey,
 					userAccount,
+					bankIndex,
 					marketIndex
 				)
 			),
@@ -2194,24 +2209,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.getRemainingAccountsWithCounterparty({
 			writableMarketIndex: marketIndex,
+			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,
+					clearingHouseSigner: this.getSignerPublicKey(),
+					tokenProgram: TOKEN_PROGRAM_ID,
+				},
+				remainingAccounts: remainingAccounts,
+			}
+		);
 	}
 
 	public async resolveBorrowBankruptcy(
@@ -2245,12 +2272,18 @@ export class ClearingHouse {
 			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,
+				clearingHouseSigner: this.getSignerPublicKey(),
+				tokenProgram: TOKEN_PROGRAM_ID,
 			},
 			remainingAccounts: remainingAccounts,
 		});
@@ -2480,4 +2513,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,
+				clearingHouseSigner: this.getSignerPublicKey(),
+				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,
+				clearingHouseSigner: this.getSignerPublicKey(),
+				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';
@@ -183,7 +183,9 @@ export class ClearingHouseUser {
 
 	/**
 	 * calculates the market position if the lp position was settled
-	 * @returns : userPosition
+	 * @returns : the settled userPosition
+	 * @returns : the dust base asset amount (ie, < stepsize)
+	 * @returns : pnl from settle
 	 */
 	public getSettledLPPosition(marketIndex: BN): [UserPosition, BN, BN] {
 		const _position = this.getUserPosition(marketIndex);
@@ -224,9 +226,6 @@ export class ClearingHouseUser {
 
 		const reaminderPerLP = remainderBaa.mul(AMM_RESERVE_PRECISION).div(nShares);
 
-		position.baseAssetAmount = position.baseAssetAmount.add(standardizedBaa);
-		position.quoteAssetAmount = position.quoteAssetAmount.add(deltaQaa);
-
 		position.lastNetBaseAssetAmountPerLp =
 			market.amm.marketPositionPerLp.baseAssetAmount.sub(reaminderPerLP);
 
@@ -254,7 +253,7 @@ export class ClearingHouseUser {
 					.mul(deltaBaa.abs())
 					.div(position.baseAssetAmount.abs())
 			);
-			pnl = position.quoteEntryAmount.sub(newQuoteEntry);
+			pnl = position.quoteEntryAmount.sub(newQuoteEntry).add(deltaQaa);
 		} else {
 			newQuoteEntry = deltaQaa.sub(
 				deltaQaa.mul(position.baseAssetAmount.abs()).div(deltaBaa.abs())
@@ -262,6 +261,8 @@ export class ClearingHouseUser {
 			pnl = position.quoteEntryAmount.add(deltaQaa.sub(newQuoteEntry));
 		}
 		position.quoteEntryAmount = newQuoteEntry;
+		position.baseAssetAmount = position.baseAssetAmount.add(standardizedBaa);
+		position.quoteAssetAmount = position.quoteAssetAmount.add(deltaQaa);
 
 		if (position.baseAssetAmount.gt(ZERO)) {
 			position.lastCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
@@ -568,7 +569,7 @@ export class ClearingHouseUser {
 				const market = this.clearingHouse.getMarketAccount(
 					marketPosition.marketIndex
 				);
-				const posVal = calculateMarginBaseAssetValue(
+				const posVal = calculateBaseAssetValueWithOracle(
 					market,
 					marketPosition,
 					this.getOracleDataForMarket(market.marketIndex)
@@ -593,7 +594,11 @@ export class ClearingHouseUser {
 		const market = this.clearingHouse.getMarketAccount(
 			userPosition.marketIndex
 		);
-		return calculateMarginBaseAssetValue(market, userPosition, oraclePriceData);
+		return calculateBaseAssetValueWithOracle(
+			market,
+			userPosition,
+			oraclePriceData
+		);
 	}
 
 	public getPositionSide(
@@ -644,7 +649,7 @@ export class ClearingHouseUser {
 				oraclePriceData
 			);
 		} else {
-			baseAssetValue = calculateMarginBaseAssetValue(
+			baseAssetValue = calculateBaseAssetValueWithOracle(
 				market,
 				position,
 				oraclePriceData
@@ -818,7 +823,7 @@ export class ClearingHouseUser {
 			proposedMarketPosition.marketIndex
 		);
 
-		const proposedMarketPositionValue = calculateMarginBaseAssetValue(
+		const proposedMarketPositionValue = calculateBaseAssetValueWithOracle(
 			market,
 			proposedMarketPosition,
 			this.getOracleDataForMarket(market.marketIndex)
@@ -835,7 +840,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: '3v1iEjbSSLSSYyt1pmx4UB5rqJGurmz71RibXF7X6UF3',
 		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));

package/src/events/eventSubscriber.ts

@@ -25,6 +25,8 @@ export class EventSubscriber {
 	private awaitTxResolver = new Map<string, () => void>();
 	private logProvider: LogProvider;
 	public eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
+	private lastSeenSlot: number;
+	public lastSeenTxSig: string;
 
 	public constructor(
 		private connection: Connection,
@@ -62,19 +64,22 @@ export class EventSubscriber {
 		}
 	}
 
-	public subscribe(): boolean {
-		if (this.logProvider.isSubscribed()) {
-			return true;
-		}
+	public async subscribe(): Promise<boolean> {
+		try {
+			if (this.logProvider.isSubscribed()) {
+				return true;
+			}
 
-		this.fetchPreviousTx().catch((e) => {
+			this.logProvider.subscribe((txSig, slot, logs) => {
+				this.handleTxLogs(txSig, slot, logs);
+			}, true);
+
+			return true;
+		} catch (e) {
 			console.error('Error fetching previous txs in event subscriber');
 			console.error(e);
-		});
-
-		return this.logProvider.subscribe((txSig, slot, logs) => {
-			this.handleTxLogs(txSig, slot, logs);
-		});
+			return false;
+		}
 	}
 
 	private handleTxLogs(
@@ -98,11 +103,14 @@ export class EventSubscriber {
 			this.awaitTxResolver.delete(txSig);
 		}
 
+		if (slot > this.lastSeenSlot) {
+			this.lastSeenTxSig = txSig;
+		}
 		this.txEventCache.add(txSig, wrappedEvents);
 	}
 
-	private async fetchPreviousTx(): Promise<void> {
-		if (!this.options.untilTx) {
+	public async fetchPreviousTx(fetchMax?: boolean): Promise<void> {
+		if (!this.options.untilTx && !fetchMax) {
 			return;
 		}
 

package/src/events/fetchLogs.ts

@@ -1,14 +1,18 @@
+import { Program } from '@project-serum/anchor';
 import {
 	Connection,
 	Finality,
 	PublicKey,
 	TransactionSignature,
 } from '@solana/web3.js';
+import { WrappedEvents } from './types';
 
 type Log = { txSig: TransactionSignature; slot: number; logs: string[] };
 type FetchLogsResponse = {
 	earliestTx: string;
 	mostRecentTx: string;
+	earliestSlot: number;
+	mostRecentSlot: number;
 	transactionLogs: Log[];
 };
 
@@ -17,19 +21,21 @@ export async function fetchLogs(
 	programId: PublicKey,
 	finality: Finality,
 	beforeTx?: TransactionSignature,
-	untilTx?: TransactionSignature
-): Promise<FetchLogsResponse | undefined> {
+	untilTx?: TransactionSignature,
+	limit?: number
+): Promise<FetchLogsResponse> {
 	const signatures = await connection.getSignaturesForAddress(
 		programId,
 		{
 			before: beforeTx,
 			until: untilTx,
+			limit,
 		},
 		finality
 	);
 
 	const sortedSignatures = signatures.sort((a, b) =>
-		a.slot < b.slot ? -1 : 1
+		a.slot === b.slot ? 0 : a.slot < b.slot ? -1 : 1
 	);
 
 	const filteredSignatures = sortedSignatures.filter(
@@ -61,14 +67,15 @@ export async function fetchLogs(
 		)
 	).flat();
 
-	const earliestTx = filteredSignatures[0].signature;
-	const mostRecentTx =
-		filteredSignatures[filteredSignatures.length - 1].signature;
+	const earliest = filteredSignatures[0];
+	const mostRecent = filteredSignatures[filteredSignatures.length - 1];
 
 	return {
 		transactionLogs: transactionLogs,
-		earliestTx: earliestTx,
-		mostRecentTx: mostRecentTx,
+		earliestTx: earliest.signature,
+		mostRecentTx: mostRecent.signature,
+		earliestSlot: earliest.slot,
+		mostRecentSlot: mostRecent.slot,
 	};
 }
 
@@ -78,3 +85,23 @@ function chunk<T>(array: readonly T[], size: number): T[][] {
 		.map((_, index) => index * size)
 		.map((begin) => array.slice(begin, begin + size));
 }
+
+export class LogParser {
+	private program: Program;
+
+	constructor(program: Program) {
+		this.program = program;
+	}
+
+	public parseEventsFromLogs(event: Log): WrappedEvents {
+		const records: WrappedEvents = [];
+		// @ts-ignore
+		this.program._events._eventParser.parseLogs(event.logs, (eventLog) => {
+			eventLog.data.txSig = event.txSig;
+			eventLog.data.slot = event.slot;
+			eventLog.data.eventType = eventLog.name;
+			records.push(eventLog.data);
+		});
+		return records;
+	}
+}

package/src/events/pollingLogProvider.ts

@@ -13,6 +13,7 @@ export class PollingLogProvider implements LogProvider {
 	private intervalId: NodeJS.Timer;
 	private mostRecentSeenTx?: TransactionSignature;
 	private mutex: number;
+	private firstFetch = true;
 
 	public constructor(
 		private connection: Connection,
@@ -23,7 +24,10 @@ export class PollingLogProvider implements LogProvider {
 		this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
 	}
 
-	public subscribe(callback: logProviderCallback): boolean {
+	public subscribe(
+		callback: logProviderCallback,
+		skipHistory?: boolean
+	): boolean {
 		if (this.intervalId) {
 			return true;
 		}
@@ -40,9 +44,13 @@ export class PollingLogProvider implements LogProvider {
 					this.programId,
 					this.finality,
 					undefined,
-					this.mostRecentSeenTx
+					this.mostRecentSeenTx,
+					// If skipping history, only fetch one log back, not the maximum amount available
+					skipHistory && this.firstFetch ? 1 : undefined
 				);
 
+				this.firstFetch = false;
+
 				if (response === undefined) {
 					return;
 				}