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

package/src/index.ts

@@ -41,6 +41,7 @@ export * from './math/trade';
 export * from './math/orders';
 export * from './math/repeg';
 export * from './math/margin';
+export * from './math/insurance';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';
 export * from './wallet';

package/src/math/insurance.ts

@@ -0,0 +1,35 @@
+import { ONE, ZERO } from '../constants/numericConstants';
+import { BN } from '../index';
+
+export function stakeAmountToShares(
+	amount: BN,
+	totalIfShares: BN,
+	insuranceFundVaultBalance: BN
+): BN {
+	let nShares: BN;
+	if (insuranceFundVaultBalance.gt(ZERO)) {
+		nShares = amount.mul(totalIfShares).div(insuranceFundVaultBalance);
+	} else {
+		nShares = amount;
+	}
+
+	return nShares;
+}
+
+export function unstakeSharesToAmount(
+	nShares: BN,
+	totalIfShares: BN,
+	insuranceFundVaultBalance: BN
+): BN {
+	let amount: BN;
+	if (totalIfShares.gt(ZERO)) {
+		amount = BN.max(
+			ZERO,
+			nShares.mul(insuranceFundVaultBalance).div(totalIfShares).sub(ONE)
+		);
+	} else {
+		amount = ZERO;
+	}
+
+	return amount;
+}

package/src/math/margin.ts

@@ -92,22 +92,15 @@ export function calculateOraclePriceForPerpMargin(
 	return marginPrice;
 }
 
-export function calculateMarginBaseAssetValue(
+export function calculateBaseAssetValueWithOracle(
 	market: MarketAccount,
 	marketPosition: UserPosition,
 	oraclePriceData: OraclePriceData
 ): BN {
-	const marginPrice = calculateOraclePriceForPerpMargin(
-		marketPosition,
-		market,
-		oraclePriceData
-	);
-	const baseAssetValue = marketPosition.baseAssetAmount
+	return marketPosition.baseAssetAmount
 		.abs()
-		.mul(marginPrice)
+		.mul(oraclePriceData.price)
 		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
-
-	return baseAssetValue;
 }
 
 export function calculateWorstCaseBaseAssetAmount(

package/src/math/position.ts

@@ -18,7 +18,7 @@ import {
 	getSwapDirection,
 } from './amm';
 
-import { calculateMarginBaseAssetValue } from './margin';
+import { calculateBaseAssetValueWithOracle } from './margin';
 
 /**
  * calculateBaseAssetValue
@@ -99,7 +99,7 @@ export function calculatePositionPNL(
 		return marketPosition.quoteAssetAmount;
 	}
 
-	const baseAssetValue = calculateMarginBaseAssetValue(
+	const baseAssetValue = calculateBaseAssetValueWithOracle(
 		market,
 		marketPosition,
 		oraclePriceData

package/src/types.ts

@@ -58,9 +58,6 @@ export class OrderAction {
 
 export class OrderActionExplanation {
 	static readonly NONE = { none: {} };
-	static readonly BREACHED_MARGIN_REQUIREMENT = {
-		breachedMarginRequirement: {},
-	};
 	static readonly ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
 		oraclePriceBreachedLimitPrice: {},
 	};
@@ -156,10 +153,15 @@ export type FundingRateRecord = {
 	recordId: BN;
 	marketIndex: BN;
 	fundingRate: BN;
+	fundingRateLong: BN;
+	fundingRateShort: BN;
 	cumulativeFundingRateLong: BN;
 	cumulativeFundingRateShort: BN;
 	oraclePriceTwap: BN;
 	markPriceTwap: BN;
+	periodRevenue: BN;
+	netBaseAssetAmount: BN;
+	netUnsettledLpBaseAssetAmount: BN;
 };
 
 export type FundingPaymentRecord = {
@@ -274,27 +276,41 @@ export type SettlePnlRecord = {
 
 export type OrderRecord = {
 	ts: BN;
-	taker: PublicKey;
-	maker: PublicKey;
-	takerOrder: Order;
-	makerOrder: Order;
-	takerPnl: BN;
-	makerPnl: BN;
+	user: PublicKey;
+	order: Order;
+};
+
+export type OrderActionRecord = {
+	ts: BN;
 	action: OrderAction;
 	actionExplanation: OrderActionExplanation;
-	filler: PublicKey;
-	fillRecordId: BN;
 	marketIndex: BN;
-	baseAssetAmountFilled: BN;
-	quoteAssetAmountFilled: BN;
-	makerRebate: BN;
-	takerFee: BN;
-	fillerReward: BN;
-	quoteAssetAmountSurplus: BN;
+	filler: PublicKey | null;
+	fillerReward: BN | null;
+	fillRecordId: BN | null;
+	referrer: PublicKey | null;
+	baseAssetAmountFilled: BN | null;
+	quoteAssetAmountFilled: BN | null;
+	takerPnl: BN | null;
+	makerPnl: BN | null;
+	takerFee: BN | null;
+	makerRebate: BN | null;
+	referrerReward: BN | null;
+	refereeDiscount: BN | null;
+	quoteAssetAmountSurplus: BN | null;
+	taker: PublicKey | null;
+	takerOrderId: BN | null;
+	takerOrderBaseAssetAmount: BN | null;
+	takerOrderBaseAssetAmountFilled: BN | null;
+	takerOrderQuoteAssetAmountFilled: BN | null;
+	takerOrderFee: BN | null;
+	maker: PublicKey | null;
+	makerOrderId: BN | null;
+	makerOrderBaseAssetAmount: BN | null;
+	makerOrderBaseAssetAmountFilled: BN | null;
+	makerOrderQuoteAssetAmountFilled: BN | null;
+	makerOrderFee: BN | null;
 	oraclePrice: BN;
-	referrer: PublicKey;
-	referrerReward: BN;
-	refereeDiscount: BN;
 };
 
 export type StateAccount = {
@@ -357,6 +373,20 @@ export type BankAccount = {
 	vault: PublicKey;
 	vaultAuthority: PublicKey;
 	vaultAuthorityNonce: number;
+
+	insuranceFundVault: PublicKey;
+	insuranceFundVaultAuthority: PublicKey;
+	insuranceFundVaultAuthorityNonce: number;
+	insuranceWithdrawEscrowPeriod: BN;
+	revenuePool: PoolBalance;
+
+	totalIfShares: BN;
+	userIfShares: BN;
+
+	userIfFactor: BN;
+	totalIfFactor: BN;
+	liquidationIfFactor: BN;
+
 	decimals: number;
 	optimalUtilization: BN;
 	optimalBorrowRate: BN;
@@ -439,6 +469,7 @@ export type AMM = {
 	maxSpread: number;
 	marketPosition: UserPosition;
 	marketPositionPerLp: UserPosition;
+	ammJitIntensity: number;
 	maxBaseAssetReserve: BN;
 	minBaseAssetReserve: BN;
 };
@@ -478,6 +509,7 @@ export type UserStatsAccount = {
 	isReferrer: boolean;
 	totalReferrerReward: BN;
 	authority: PublicKey;
+	quoteAssetInsuranceFundStake: BN;
 };
 
 export type UserAccount = {
@@ -664,3 +696,15 @@ export type OrderFillerRewardStructure = {
 };
 
 export type MarginCategory = 'Initial' | 'Maintenance';
+
+export type InsuranceFundStake = {
+	bankIndex: BN;
+	authority: PublicKey;
+
+	ifShares: BN;
+	ifBase: BN;
+
+	lastWithdrawRequestShares: BN;
+	lastWithdrawRequestValue: BN;
+	lastWithdrawRequestTs: BN;
+};

package/src/events/eventSubscriber.js

@@ -1,139 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventSubscriber = void 0;
-const types_1 = require("./types");
-const txEventCache_1 = require("./txEventCache");
-const eventList_1 = require("./eventList");
-const pollingLogProvider_1 = require("./pollingLogProvider");
-const fetchLogs_1 = require("./fetchLogs");
-const webSocketLogProvider_1 = require("./webSocketLogProvider");
-const events_1 = require("events");
-const sort_1 = require("./sort");
-class EventSubscriber {
-    constructor(connection, program, options = types_1.DefaultEventSubscriptionOptions) {
-        this.connection = connection;
-        this.program = program;
-        this.options = options;
-        this.awaitTxPromises = new Map();
-        this.awaitTxResolver = new Map();
-        this.options = Object.assign({}, types_1.DefaultEventSubscriptionOptions, options);
-        this.txEventCache = new txEventCache_1.TxEventCache(this.options.maxTx);
-        this.eventListMap = new Map();
-        for (const eventType of this.options.eventTypes) {
-            this.eventListMap.set(eventType, new eventList_1.EventList(eventType, this.options.maxEventsPerType, sort_1.getSortFn(this.options.orderBy, this.options.orderDir, eventType), this.options.orderDir));
-        }
-        this.eventEmitter = new events_1.EventEmitter();
-        if (this.options.logProviderConfig.type === 'websocket') {
-            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(this.connection, this.program.programId, this.options.commitment);
-        }
-        else {
-            this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.program.programId, options.commitment, this.options.logProviderConfig.frequency);
-        }
-    }
-    subscribe() {
-        if (this.logProvider.isSubscribed()) {
-            return true;
-        }
-        this.fetchPreviousTx().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);
-        });
-    }
-    handleTxLogs(txSig, slot, logs) {
-        if (this.txEventCache.has(txSig)) {
-            return;
-        }
-        const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs);
-        for (const wrappedEvent of wrappedEvents) {
-            this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
-            this.eventEmitter.emit('newEvent', wrappedEvent);
-        }
-        if (this.awaitTxPromises.has(txSig)) {
-            this.awaitTxPromises.delete(txSig);
-            this.awaitTxResolver.get(txSig)();
-            this.awaitTxResolver.delete(txSig);
-        }
-        this.txEventCache.add(txSig, wrappedEvents);
-    }
-    fetchPreviousTx() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.options.untilTx) {
-                return;
-            }
-            let txFetched = 0;
-            let beforeTx = undefined;
-            const untilTx = this.options.untilTx;
-            while (txFetched < this.options.maxTx) {
-                const response = yield fetchLogs_1.fetchLogs(this.connection, this.program.programId, this.options.commitment === 'finalized' ? 'finalized' : 'confirmed', beforeTx, untilTx);
-                if (response === undefined) {
-                    break;
-                }
-                txFetched += response.transactionLogs.length;
-                beforeTx = response.earliestTx;
-                for (const { txSig, slot, logs } of response.transactionLogs) {
-                    this.handleTxLogs(txSig, slot, logs);
-                }
-            }
-        });
-    }
-    unsubscribe() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.logProvider.unsubscribe();
-        });
-    }
-    parseEventsFromLogs(txSig, slot, logs) {
-        const records = [];
-        // @ts-ignore
-        this.program._events._eventParser.parseLogs(logs, (event) => {
-            const expectRecordType = this.eventListMap.has(event.name);
-            if (expectRecordType) {
-                event.data.txSig = txSig;
-                event.data.slot = slot;
-                event.data.eventType = event.name;
-                records.push(event.data);
-            }
-        });
-        return records;
-    }
-    awaitTx(txSig) {
-        if (this.awaitTxPromises.has(txSig)) {
-            return this.awaitTxPromises.get(txSig);
-        }
-        if (this.txEventCache.has(txSig)) {
-            return Promise.resolve();
-        }
-        const promise = new Promise((resolve) => {
-            this.awaitTxResolver.set(txSig, resolve);
-        });
-        this.awaitTxPromises.set(txSig, promise);
-        return promise;
-    }
-    getEventList(eventType) {
-        return this.eventListMap.get(eventType);
-    }
-    /**
-     * This requires the EventList be cast to an array, which requires reallocation of memory.
-     * Would bias to using getEventList over getEvents
-     *
-     * @param eventType
-     */
-    getEventsArray(eventType) {
-        return this.eventListMap.get(eventType).toArray();
-    }
-    getEventsByTx(txSig) {
-        return this.txEventCache.get(txSig);
-    }
-}
-exports.EventSubscriber = EventSubscriber;

package/src/events/sort.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSortFn = void 0;
-const index_1 = require("../index");
-function clientSortAscFn() {
-    return 'less than';
-}
-function clientSortDescFn() {
-    return 'greater than';
-}
-function defaultBlockchainSortFn(currentEvent, newEvent) {
-    return currentEvent.slot <= newEvent.slot ? 'less than' : 'greater than';
-}
-function orderRecordSortFn(currentEvent, newEvent) {
-    const currentEventMarketIndex = !currentEvent.maker.equals(index_1.PublicKey.default)
-        ? currentEvent.makerOrder.marketIndex
-        : currentEvent.takerOrder.marketIndex;
-    const newEventMarketIndex = !newEvent.maker.equals(index_1.PublicKey.default)
-        ? newEvent.makerOrder.marketIndex
-        : newEvent.takerOrder.marketIndex;
-    if (!currentEventMarketIndex.eq(newEventMarketIndex)) {
-        return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
-    }
-    if (currentEvent.fillRecordId.gt(index_1.ZERO) && newEvent.fillRecordId.gt(index_1.ZERO)) {
-        return currentEvent.fillRecordId.lte(newEvent.fillRecordId)
-            ? 'less than'
-            : 'greater than';
-    }
-    else {
-        return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
-    }
-}
-function getSortFn(orderBy, orderDir, eventType) {
-    if (orderBy === 'client') {
-        return orderDir === 'asc' ? clientSortAscFn : clientSortDescFn;
-    }
-    switch (eventType) {
-        case 'OrderRecord':
-            return orderRecordSortFn;
-        default:
-            return defaultBlockchainSortFn;
-    }
-}
-exports.getSortFn = getSortFn;