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

package/src/index.ts

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

package/src/math/amm.ts

@@ -19,7 +19,7 @@ import {
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
-import { squareRootBN } from '..';
+import { squareRootBN, standardizeBaseAssetAmount } from '..';
 
 import { OraclePriceData } from '../oracles/types';
 import {
@@ -623,3 +623,29 @@ export function calculateQuoteAssetAmountSwapped(
 
 	return quoteAssetAmount;
 }
+
+export function calculateMaxBaseAssetAmountFillable(
+	amm: AMM,
+	orderDirection: PositionDirection
+): BN {
+	const maxFillSize = amm.baseAssetReserve.div(
+		new BN(amm.maxBaseAssetAmountRatio)
+	);
+	let maxBaseAssetAmountOnSide: BN;
+	if (isVariant(orderDirection, 'long')) {
+		maxBaseAssetAmountOnSide = BN.max(
+			ZERO,
+			amm.maxBaseAssetReserve.sub(amm.baseAssetReserve)
+		);
+	} else {
+		maxBaseAssetAmountOnSide = BN.max(
+			ZERO,
+			amm.baseAssetReserve.sub(amm.minBaseAssetReserve)
+		);
+	}
+
+	return standardizeBaseAssetAmount(
+		BN.min(maxFillSize, maxBaseAssetAmountOnSide),
+		amm.baseAssetAmountStepSize
+	);
+}

package/src/math/market.ts

@@ -139,9 +139,9 @@ export function calculateMarketMarginRatio(
 	return marginRatio;
 }
 
-export function calculateUnsettledAssetWeight(
+export function calculateUnrealizedAssetWeight(
 	market: MarketAccount,
-	unsettledPnl: BN,
+	unrealizedPnl: BN,
 	marginCategory: MarginCategory
 ): BN {
 	let assetWeight: BN;
@@ -149,13 +149,13 @@ export function calculateUnsettledAssetWeight(
 	switch (marginCategory) {
 		case 'Initial':
 			assetWeight = calculateSizeDiscountAssetWeight(
-				unsettledPnl,
-				market.unsettledImfFactor,
-				new BN(market.unsettledInitialAssetWeight)
+				unrealizedPnl,
+				market.unrealizedImfFactor,
+				new BN(market.unrealizedInitialAssetWeight)
 			);
 			break;
 		case 'Maintenance':
-			assetWeight = new BN(market.unsettledMaintenanceAssetWeight);
+			assetWeight = new BN(market.unrealizedMaintenanceAssetWeight);
 			break;
 	}
 

package/src/math/orders.ts

@@ -1,10 +1,20 @@
 import { ClearingHouseUser } from '../clearingHouseUser';
-import { isOneOfVariant, isVariant, MarketAccount, Order } from '../types';
+import {
+	isOneOfVariant,
+	isVariant,
+	MarketAccount,
+	Order,
+	PositionDirection,
+} from '../types';
 import { ZERO, TWO } from '../constants/numericConstants';
 import { BN } from '@project-serum/anchor';
 import { OraclePriceData } from '../oracles/types';
 import { getAuctionPrice, isAuctionComplete } from './auction';
 import { calculateAskPrice, calculateBidPrice } from './market';
+import {
+	calculateMaxBaseAssetAmountFillable,
+	calculateMaxBaseAssetAmountToTrade,
+} from './amm';
 
 export function isOrderRiskIncreasing(
 	user: ClearingHouseUser,
@@ -148,3 +158,88 @@ export function getLimitPrice(
 
 	return limitPrice;
 }
+
+export function isFillableByVAMM(
+	order: Order,
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData,
+	slot: number
+): boolean {
+	return (
+		isAuctionComplete(order, slot) &&
+		!calculateBaseAssetAmountForAmmToFulfill(
+			order,
+			market,
+			oraclePriceData,
+			slot
+		).eq(ZERO)
+	);
+}
+
+export function calculateBaseAssetAmountForAmmToFulfill(
+	order: Order,
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData,
+	slot: number
+): BN {
+	if (
+		isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']) &&
+		order.triggered === false
+	) {
+		return ZERO;
+	}
+
+	const limitPrice = getLimitPrice(order, market, oraclePriceData, slot);
+	const baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(
+		order,
+		market,
+		limitPrice,
+		oraclePriceData
+	);
+
+	const maxBaseAssetAmount = calculateMaxBaseAssetAmountFillable(
+		market.amm,
+		order.direction
+	);
+
+	return BN.min(maxBaseAssetAmount, baseAssetAmount);
+}
+
+export function calculateBaseAssetAmountToFillUpToLimitPrice(
+	order: Order,
+	market: MarketAccount,
+	limitPrice: BN,
+	oraclePriceData: OraclePriceData
+): BN {
+	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
+		market.amm,
+		limitPrice,
+		order.direction,
+		oraclePriceData
+	);
+
+	const baseAssetAmount = standardizeBaseAssetAmount(
+		maxAmountToTrade,
+		market.amm.baseAssetAmountStepSize
+	);
+
+	// Check that directions are the same
+	const sameDirection = isSameDirection(direction, order.direction);
+	if (!sameDirection) {
+		return ZERO;
+	}
+
+	return baseAssetAmount.gt(order.baseAssetAmount)
+		? order.baseAssetAmount
+		: baseAssetAmount;
+}
+
+function isSameDirection(
+	firstDirection: PositionDirection,
+	secondDirection: PositionDirection
+): boolean {
+	return (
+		(isVariant(firstDirection, 'long') && isVariant(secondDirection, 'long')) ||
+		(isVariant(firstDirection, 'short') && isVariant(secondDirection, 'short'))
+	);
+}

package/src/types.ts

@@ -106,6 +106,15 @@ export type CandleResolution =
 	| 'W'
 	| 'M';
 
+export type NewUserRecord = {
+	ts: BN;
+	userAuthority: PublicKey;
+	user: PublicKey;
+	userId: number;
+	name: number[];
+	referrer: PublicKey;
+};
+
 export type DepositRecord = {
 	ts: BN;
 	userAuthority: PublicKey;
@@ -117,6 +126,7 @@ export type DepositRecord = {
 	bankIndex: BN;
 	amount: BN;
 	oraclePrice: BN;
+	referrer: PublicKey;
 	from?: PublicKey;
 	to?: PublicKey;
 };
@@ -282,6 +292,9 @@ export type OrderRecord = {
 	fillerReward: BN;
 	quoteAssetAmountSurplus: BN;
 	oraclePrice: BN;
+	referrer: PublicKey;
+	referrerReward: BN;
+	refereeDiscount: BN;
 };
 
 export type StateAccount = {
@@ -330,9 +343,9 @@ export type MarketAccount = {
 	pnlPool: PoolBalance;
 	liquidationFee: BN;
 	imfFactor: BN;
-	unsettledImfFactor: BN;
-	unsettledInitialAssetWeight: number;
-	unsettledMaintenanceAssetWeight: number;
+	unrealizedImfFactor: BN;
+	unrealizedInitialAssetWeight: number;
+	unrealizedMaintenanceAssetWeight: number;
 };
 
 export type BankAccount = {
@@ -424,6 +437,8 @@ export type AMM = {
 	maxSpread: number;
 	marketPosition: UserPosition;
 	marketPositionPerLp: UserPosition;
+	maxBaseAssetReserve: BN;
+	minBaseAssetReserve: BN;
 };
 
 // # User Account Types
@@ -455,11 +470,12 @@ export type UserStatsAccount = {
 		totalFeePaid: BN;
 		totalFeeRebate: BN;
 		totalTokenDiscount: BN;
-		totalReferralReward: BN;
 		totalRefereeDiscount: BN;
 	};
-	authority: PublicKey;
 	referrer: PublicKey;
+	isReferrer: boolean;
+	totalReferrerReward: BN;
+	authority: PublicKey;
 };
 
 export type UserAccount = {
@@ -472,6 +488,7 @@ export type UserAccount = {
 	beingLiquidated: boolean;
 	bankrupt: boolean;
 	nextLiquidationId: number;
+	nextOrderId: BN;
 };
 
 export type UserBankBalance = {
@@ -499,9 +516,7 @@ export type Order = {
 	triggerPrice: BN;
 	triggerCondition: OrderTriggerCondition;
 	triggered: boolean;
-	discountTier: OrderDiscountTier;
 	existingPositionDirection: PositionDirection;
-	referrer: PublicKey;
 	postOnly: boolean;
 	immediateOrCancel: boolean;
 	oraclePriceOffset: BN;
@@ -577,6 +592,11 @@ export type TakerInfo = {
 	order: Order;
 };
 
+export type ReferrerInfo = {
+	referrer: PublicKey;
+	referrerStats: PublicKey;
+};
+
 // # Misc Types
 export interface IWallet {
 	signTransaction(tx: Transaction): Promise<Transaction>;

package/lib/orders.d.ts

@@ -1,7 +0,0 @@
-/// <reference types="bn.js" />
-import { MarketAccount, Order } from './types';
-import { BN } from '.';
-import { OraclePriceData } from '.';
-export declare function calculateBaseAssetAmountMarketCanExecute(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
-export declare function calculateAmountToTradeForLimit(market: MarketAccount, order: Order, oraclePriceData?: OraclePriceData): BN;
-export declare function calculateAmountToTradeForTriggerLimit(market: MarketAccount, order: Order): BN;

package/lib/orders.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = void 0;
-const types_1 = require("./types");
-const _1 = require(".");
-const numericConstants_1 = require("./constants/numericConstants");
-const amm_1 = require("./math/amm");
-function calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData) {
-    if ((0, types_1.isVariant)(order.orderType, 'limit')) {
-        return calculateAmountToTradeForLimit(market, order, oraclePriceData);
-    }
-    else if ((0, types_1.isVariant)(order.orderType, 'triggerLimit')) {
-        return calculateAmountToTradeForTriggerLimit(market, order);
-    }
-    else if ((0, types_1.isVariant)(order.orderType, 'market')) {
-        return numericConstants_1.ZERO;
-    }
-    else {
-        return calculateAmountToTradeForTriggerMarket(market, order);
-    }
-}
-exports.calculateBaseAssetAmountMarketCanExecute = calculateBaseAssetAmountMarketCanExecute;
-function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
-    let limitPrice = order.price;
-    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
-        if (!oraclePriceData) {
-            throw Error('Cant calculate limit price for oracle offset oracle without OraclePriceData');
-        }
-        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-    }
-    const [maxAmountToTrade, direction] = (0, amm_1.calculateMaxBaseAssetAmountToTrade)(market.amm, limitPrice, order.direction, oraclePriceData);
-    const baseAssetAmount = (0, _1.standardizeBaseAssetAmount)(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
-    // Check that directions are the same
-    const sameDirection = isSameDirection(direction, order.direction);
-    if (!sameDirection) {
-        return numericConstants_1.ZERO;
-    }
-    return baseAssetAmount.gt(order.baseAssetAmount)
-        ? order.baseAssetAmount
-        : baseAssetAmount;
-}
-exports.calculateAmountToTradeForLimit = calculateAmountToTradeForLimit;
-function calculateAmountToTradeForTriggerLimit(market, order) {
-    if (!order.triggered) {
-        return numericConstants_1.ZERO;
-    }
-    return calculateAmountToTradeForLimit(market, order);
-}
-exports.calculateAmountToTradeForTriggerLimit = calculateAmountToTradeForTriggerLimit;
-function isSameDirection(firstDirection, secondDirection) {
-    return (((0, types_1.isVariant)(firstDirection, 'long') && (0, types_1.isVariant)(secondDirection, 'long')) ||
-        ((0, types_1.isVariant)(firstDirection, 'short') && (0, types_1.isVariant)(secondDirection, 'short')));
-}
-function calculateAmountToTradeForTriggerMarket(market, order) {
-    if (!order.triggered) {
-        return numericConstants_1.ZERO;
-    }
-    return order.baseAssetAmount;
-}

package/src/events/types.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultEventSubscriptionOptions = void 0;
-exports.DefaultEventSubscriptionOptions = {
-    eventTypes: [
-        'DepositRecord',
-        'FundingPaymentRecord',
-        'LiquidationRecord',
-        'OrderRecord',
-        'FundingRateRecord',
-    ],
-    maxEventsPerType: 4096,
-    orderBy: 'blockchain',
-    orderDir: 'asc',
-    commitment: 'confirmed',
-    maxTx: 4096,
-    logProviderConfig: {
-        type: 'websocket',
-    },
-};