@drift-labs/sdk 2.10.0-beta.1 → 2.10.0-beta.3

package/lib/events/types.d.ts

@@ -1,6 +1,6 @@
 import { Commitment, TransactionSignature } from '@solana/web3.js';
 import { DepositRecord, FundingPaymentRecord, FundingRateRecord, LiquidationRecord, NewUserRecord, OrderActionRecord, OrderRecord, SettlePnlRecord, LPRecord, InsuranceFundRecord, SpotInterestRecord, InsuranceFundStakeRecord, CurveRecord } from '../index';
-export declare type EventSubscriptionOptions = {
+export type EventSubscriptionOptions = {
     eventTypes?: EventType[];
     maxEventsPerType?: number;
     orderBy?: EventSubscriptionOrderBy;
@@ -11,17 +11,17 @@ export declare type EventSubscriptionOptions = {
     untilTx?: TransactionSignature;
 };
 export declare const DefaultEventSubscriptionOptions: EventSubscriptionOptions;
-export declare type EventSubscriptionOrderBy = 'blockchain' | 'client';
-export declare type EventSubscriptionOrderDirection = 'asc' | 'desc';
-export declare type Event<T> = T & {
+export type EventSubscriptionOrderBy = 'blockchain' | 'client';
+export type EventSubscriptionOrderDirection = 'asc' | 'desc';
+export type Event<T> = T & {
     txSig: TransactionSignature;
     slot: number;
 };
-export declare type WrappedEvent<Type extends EventType> = EventMap[Type] & {
+export type WrappedEvent<Type extends EventType> = EventMap[Type] & {
     eventType: Type;
 };
-export declare type WrappedEvents = WrappedEvent<EventType>[];
-export declare type EventMap = {
+export type WrappedEvents = WrappedEvent<EventType>[];
+export type EventMap = {
     DepositRecord: Event<DepositRecord>;
     FundingPaymentRecord: Event<FundingPaymentRecord>;
     LiquidationRecord: Event<LiquidationRecord>;
@@ -36,22 +36,22 @@ export declare type EventMap = {
     InsuranceFundStakeRecord: Event<InsuranceFundStakeRecord>;
     CurveRecord: Event<CurveRecord>;
 };
-export declare type EventType = keyof EventMap;
+export type EventType = keyof EventMap;
 export interface EventSubscriberEvents {
     newEvent: (event: WrappedEvent<EventType>) => void;
 }
-export declare type SortFn = (currentRecord: EventMap[EventType], newRecord: EventMap[EventType]) => 'less than' | 'greater than';
-export declare type logProviderCallback = (txSig: TransactionSignature, slot: number, logs: string[], mostRecentBlockTime: number | undefined) => void;
+export type SortFn = (currentRecord: EventMap[EventType], newRecord: EventMap[EventType]) => 'less than' | 'greater than';
+export type logProviderCallback = (txSig: TransactionSignature, slot: number, logs: string[], mostRecentBlockTime: number | undefined) => void;
 export interface LogProvider {
     isSubscribed(): boolean;
     subscribe(callback: logProviderCallback, skipHistory?: boolean): boolean;
     unsubscribe(): Promise<boolean>;
 }
-export declare type WebSocketLogProviderConfig = {
+export type WebSocketLogProviderConfig = {
     type: 'websocket';
 };
-export declare type PollingLogProviderConfig = {
+export type PollingLogProviderConfig = {
     type: 'polling';
     frequency: number;
 };
-export declare type LogProviderConfig = WebSocketLogProviderConfig | PollingLogProviderConfig;
+export type LogProviderConfig = WebSocketLogProviderConfig | PollingLogProviderConfig;

package/lib/factory/bigNum.js

@@ -5,15 +5,15 @@ const anchor_1 = require("@project-serum/anchor");
 const assert_1 = require("../assert/assert");
 const numericConstants_1 = require("./../constants/numericConstants");
 class BigNum {
+    static setLocale(locale) {
+        BigNum.delim = (1.1).toLocaleString(locale).slice(1, 2) || '.';
+        BigNum.spacer = (1000).toLocaleString(locale).slice(1, 2) || ',';
+    }
     constructor(val, precisionVal = new anchor_1.BN(0)) {
         this.toString = (base, length) => this.val.toString(base, length);
         this.val = new anchor_1.BN(val);
         this.precision = new anchor_1.BN(precisionVal);
     }
-    static setLocale(locale) {
-        BigNum.delim = (1.1).toLocaleString(locale).slice(1, 2) || '.';
-        BigNum.spacer = (1000).toLocaleString(locale).slice(1, 2) || ',';
-    }
     bigNumFromParam(bn) {
         return anchor_1.BN.isBN(bn) ? BigNum.from(bn) : bn;
     }

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.10.0-beta.1",
+    "version": "2.10.0-beta.3",
     "name": "drift",
     "instructions": [
         {

package/lib/index.d.ts

@@ -20,6 +20,7 @@ export * from './accounts/pollingUserStatsAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses/pda';
 export * from './adminClient';
+export * from './testClient';
 export * from './user';
 export * from './userConfig';
 export * from './userStats';

package/lib/index.js

@@ -43,6 +43,7 @@ __exportStar(require("./accounts/pollingUserStatsAccountSubscriber"), exports);
 __exportStar(require("./accounts/types"), exports);
 __exportStar(require("./addresses/pda"), exports);
 __exportStar(require("./adminClient"), exports);
+__exportStar(require("./testClient"), exports);
 __exportStar(require("./user"), exports);
 __exportStar(require("./userConfig"), exports);
 __exportStar(require("./userStats"), exports);

package/lib/math/amm.d.ts

@@ -22,7 +22,7 @@ export declare function calculateBidAskPrice(amm: AMM, oraclePriceData: OraclePr
  * @returns price : Precision PRICE_PRECISION
  */
 export declare function calculatePrice(baseAssetReserves: BN, quoteAssetReserves: BN, pegMultiplier: BN): BN;
-export declare type AssetType = 'quote' | 'base';
+export type AssetType = 'quote' | 'base';
 /**
  * Calculates what the amm reserves would be after swapping a quote or base asset amount.
  *

package/lib/math/amm.js

@@ -23,6 +23,7 @@ function calculateOptimalPegAndBudget(amm, oraclePriceData) {
     const prePegCost = (0, repeg_1.calculateRepegCost)(amm, newPeg);
     const totalFeeLB = amm.totalExchangeFee.div(new anchor_1.BN(2));
     const budget = anchor_1.BN.max(numericConstants_1.ZERO, amm.totalFeeMinusDistributions.sub(totalFeeLB));
+    let checkLowerBound = true;
     if (budget.lt(prePegCost)) {
         const halfMaxPriceSpread = new anchor_1.BN(amm.maxSpread)
             .div(new anchor_1.BN(2))
@@ -42,19 +43,23 @@ function calculateOptimalPegAndBudget(amm, oraclePriceData) {
             }
             newOptimalPeg = calculatePegFromTargetPrice(newTargetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
             newBudget = (0, repeg_1.calculateRepegCost)(amm, newOptimalPeg);
+            checkLowerBound = false;
             return [newTargetPrice, newOptimalPeg, newBudget, false];
         }
+        else if (amm.totalFeeMinusDistributions.lt(amm.totalExchangeFee.div(new anchor_1.BN(2)))) {
+            checkLowerBound = false;
+        }
     }
-    return [targetPrice, newPeg, budget, true];
+    return [targetPrice, newPeg, budget, checkLowerBound];
 }
 exports.calculateOptimalPegAndBudget = calculateOptimalPegAndBudget;
 function calculateNewAmm(amm, oraclePriceData) {
     let pKNumer = new anchor_1.BN(1);
     let pKDenom = new anchor_1.BN(1);
-    const [targetPrice, _newPeg, budget, checkLowerBound] = calculateOptimalPegAndBudget(amm, oraclePriceData);
+    const [targetPrice, _newPeg, budget, _checkLowerBound] = calculateOptimalPegAndBudget(amm, oraclePriceData);
     let prePegCost = (0, repeg_1.calculateRepegCost)(amm, _newPeg);
     let newPeg = _newPeg;
-    if (prePegCost.gt(budget) && checkLowerBound) {
+    if (prePegCost.gte(budget) && prePegCost.gt(numericConstants_1.ZERO)) {
         [pKNumer, pKDenom] = [new anchor_1.BN(999), new anchor_1.BN(1000)];
         const deficitMadeup = (0, repeg_1.calculateAdjustKCost)(amm, pKNumer, pKDenom);
         (0, assert_1.assert)(deficitMadeup.lte(new anchor_1.BN(0)));
@@ -76,7 +81,7 @@ function calculateNewAmm(amm, oraclePriceData) {
 }
 exports.calculateNewAmm = calculateNewAmm;
 function calculateUpdatedAMM(amm, oraclePriceData) {
-    if (amm.curveUpdateIntensity == 0) {
+    if (amm.curveUpdateIntensity == 0 || oraclePriceData === undefined) {
         return amm;
     }
     const newAmm = Object.assign({}, amm);
@@ -325,8 +330,12 @@ function calculateSpreadBN(baseSpread, lastOracleReservePriceSpreadPct, lastOrac
     spreadTerms.longSpreadwEL = longSpread;
     spreadTerms.shortSpreadwEL = shortSpread;
     if (netRevenueSinceLastFunding.lt(numericConstants_1.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT)) {
-        const revenueRetreatAmount = Math.min(maxTargetSpread / 10, Math.floor((baseSpread * netRevenueSinceLastFunding.abs().toNumber()) /
-            numericConstants_1.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.abs().toNumber()));
+        const maxRetreat = maxTargetSpread / 10;
+        let revenueRetreatAmount = maxRetreat;
+        if (netRevenueSinceLastFunding.gte(numericConstants_1.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.mul(new anchor_1.BN(1000)))) {
+            revenueRetreatAmount = Math.min(maxRetreat, Math.floor((baseSpread * netRevenueSinceLastFunding.abs().toNumber()) /
+                numericConstants_1.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.abs().toNumber()));
+        }
         const halfRevenueRetreatAmount = Math.floor(revenueRetreatAmount / 2);
         spreadTerms.revenueRetreatAmount = revenueRetreatAmount;
         spreadTerms.halfRevenueRetreatAmount = halfRevenueRetreatAmount;

package/lib/math/oracles.js

@@ -53,7 +53,7 @@ function isOracleTooDivergent(amm, oraclePriceData, oracleGuardRails, now) {
 }
 exports.isOracleTooDivergent = isOracleTooDivergent;
 function calculateLiveOracleTwap(amm, oraclePriceData, now) {
-    const sinceLastUpdate = now.sub(amm.historicalOracleData.lastOraclePriceTwapTs);
+    const sinceLastUpdate = index_1.BN.max(numericConstants_1.ONE, now.sub(amm.historicalOracleData.lastOraclePriceTwapTs));
     const sinceStart = index_1.BN.max(numericConstants_1.ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
     const clampRange = amm.historicalOracleData.lastOraclePriceTwap.div(new index_1.BN(3));
     const clampedOraclePrice = index_1.BN.min(amm.historicalOracleData.lastOraclePriceTwap.add(clampRange), index_1.BN.max(oraclePriceData.price, amm.historicalOracleData.lastOraclePriceTwap.sub(clampRange)));
@@ -65,7 +65,7 @@ function calculateLiveOracleTwap(amm, oraclePriceData, now) {
 }
 exports.calculateLiveOracleTwap = calculateLiveOracleTwap;
 function calculateLiveOracleStd(amm, oraclePriceData, now) {
-    const sinceLastUpdate = now.sub(amm.historicalOracleData.lastOraclePriceTwapTs);
+    const sinceLastUpdate = index_1.BN.max(numericConstants_1.ONE, now.sub(amm.historicalOracleData.lastOraclePriceTwapTs));
     const sinceStart = index_1.BN.max(numericConstants_1.ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
     const liveOracleTwap = calculateLiveOracleTwap(amm, oraclePriceData, now);
     const priceDeltaVsTwap = oraclePriceData.price.sub(liveOracleTwap).abs();

package/lib/math/repeg.d.ts

@@ -19,4 +19,4 @@ export declare function calculateAdjustKCost(amm: AMM, numerator: BN, denomenato
 export declare function calculateRepegCost(amm: AMM, newPeg: BN): BN;
 export declare function calculateBudgetedKBN(x: BN, y: BN, budget: BN, Q: BN, d: BN): [BN, BN];
 export declare function calculateBudgetedK(amm: AMM, cost: BN): [BN, BN];
-export declare function calculateBudgetedPeg(amm: AMM, cost: BN, targetPrice: BN): BN;
+export declare function calculateBudgetedPeg(amm: AMM, budget: BN, targetPrice: BN): BN;

package/lib/math/repeg.js

@@ -20,16 +20,46 @@ function calculateAdjustKCost(amm, numerator, denomenator) {
     const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
     const p = numerator.mul(numericConstants_1.PRICE_PRECISION).div(denomenator);
     const cost = quoteScale
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
         .div(x.add(d))
         .sub(quoteScale
         .mul(p)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
         .div(numericConstants_1.PRICE_PRECISION)
         .div(x.mul(p).div(numericConstants_1.PRICE_PRECISION).add(d)))
+        .div(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(numericConstants_1.PERCENTAGE_PRECISION)
         .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(numericConstants_1.PEG_PRECISION);
     return cost.mul(new anchor_1.BN(-1));
 }
 exports.calculateAdjustKCost = calculateAdjustKCost;
+// /**
+//  * Helper function calculating adjust k cost
+//  * @param amm
+//  * @param numerator
+//  * @param denomenator
+//  * @returns cost : Precision QUOTE_ASSET_PRECISION
+//  */
+// export function calculateAdjustKCost2(
+// 	amm: AMM,
+// 	numerator: BN,
+// 	denomenator: BN
+// ): BN {
+// 	// const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+// 	const directionToClose = amm.baseAssetAmountWithAmm.gt(ZERO)
+// 		? PositionDirection.SHORT
+// 		: PositionDirection.LONG;
+// 	const [newQuoteAssetReserve, _newBaseAssetReserve] =
+// 		calculateAmmReservesAfterSwap(
+// 			amm,
+// 			'base',
+// 			amm.baseAssetAmountWithAmm.abs(),
+// 			getSwapDirection('base', directionToClose)
+// 		);
+// }
 /**
  * Helper function calculating adjust pegMultiplier (repeg) cost
  *
@@ -107,31 +137,28 @@ function calculateBudgetedK(amm, cost) {
     return [numerator, denominator];
 }
 exports.calculateBudgetedK = calculateBudgetedK;
-function calculateBudgetedPeg(amm, cost, targetPrice) {
-    // wolframalpha.com
-    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
-    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
-    // todo: assumes k = x * y
-    // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
+function calculateBudgetedPeg(amm, budget, targetPrice) {
+    let perPegCost = amm.quoteAssetReserve
+        .sub(amm.terminalQuoteAssetReserve)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION.div(numericConstants_1.PRICE_PRECISION));
+    if (perPegCost.gt(numericConstants_1.ZERO)) {
+        perPegCost = perPegCost.add(numericConstants_1.ONE);
+    }
+    else if (perPegCost.lt(numericConstants_1.ZERO)) {
+        perPegCost = perPegCost.sub(numericConstants_1.ONE);
+    }
     const targetPeg = targetPrice
         .mul(amm.baseAssetReserve)
         .div(amm.quoteAssetReserve)
         .div(numericConstants_1.PRICE_DIV_PEG);
-    const k = amm.sqrtK.mul(amm.sqrtK);
-    const x = amm.baseAssetReserve;
-    const y = amm.quoteAssetReserve;
-    const d = amm.baseAssetAmountWithAmm;
-    const Q = amm.pegMultiplier;
-    const C = cost.mul(new anchor_1.BN(-1));
-    const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
-    const pegChangeDirection = targetPeg.sub(Q);
-    const useTargetPeg = (deltaQuoteAssetReserves.lt(numericConstants_1.ZERO) && pegChangeDirection.gt(numericConstants_1.ZERO)) ||
-        (deltaQuoteAssetReserves.gt(numericConstants_1.ZERO) && pegChangeDirection.lt(numericConstants_1.ZERO));
-    if (deltaQuoteAssetReserves.eq(numericConstants_1.ZERO) || useTargetPeg) {
+    const pegChangeDirection = targetPeg.sub(amm.pegMultiplier);
+    const useTargetPeg = (perPegCost.lt(numericConstants_1.ZERO) && pegChangeDirection.gt(numericConstants_1.ZERO)) ||
+        (perPegCost.gt(numericConstants_1.ZERO) && pegChangeDirection.lt(numericConstants_1.ZERO));
+    if (perPegCost.eq(numericConstants_1.ZERO) || useTargetPeg) {
         return targetPeg;
     }
-    const deltaPegMultiplier = C.mul(numericConstants_1.PRICE_PRECISION).div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO));
-    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.PRICE_PRECISION));
+    const budgetDeltaPeg = budget.mul(numericConstants_1.PEG_PRECISION).div(perPegCost);
+    const newPeg = anchor_1.BN.max(numericConstants_1.ONE, amm.pegMultiplier.add(budgetDeltaPeg));
     return newPeg;
 }
 exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/lib/math/trade.d.ts

@@ -3,7 +3,7 @@ import { PerpMarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { AssetType } from './amm';
 import { OraclePriceData } from '../oracles/types';
-export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' | 'priceDeltaAsNumber' | 'pctAvg' | 'pctMax' | 'quoteAssetAmount' | 'quoteAssetAmountPeg' | 'acquiredBaseAssetAmount' | 'acquiredQuoteAssetAmount' | 'all';
+export type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' | 'priceDeltaAsNumber' | 'pctAvg' | 'pctMax' | 'quoteAssetAmount' | 'quoteAssetAmountPeg' | 'acquiredBaseAssetAmount' | 'acquiredQuoteAssetAmount' | 'all';
 /**
  * Calculates avg/max slippage (price impact) for candidate trade
  * @param direction

package/lib/oracles/types.d.ts

@@ -3,7 +3,7 @@
 import { BN } from '@project-serum/anchor';
 import { PublicKey } from '@solana/web3.js';
 import { OracleSource } from '../types';
-export declare type OraclePriceData = {
+export type OraclePriceData = {
     price: BN;
     slot: BN;
     confidence: BN;
@@ -11,7 +11,7 @@ export declare type OraclePriceData = {
     twap?: BN;
     twapConfidence?: BN;
 };
-export declare type OracleInfo = {
+export type OracleInfo = {
     publicKey: PublicKey;
     source: OracleSource;
 };

package/lib/serum/types.d.ts

@@ -1,6 +1,6 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
-export declare type SerumMarketSubscriberConfig = {
+export type SerumMarketSubscriberConfig = {
     connection: Connection;
     programId: PublicKey;
     marketAddress: PublicKey;

package/lib/slot/SlotSubscriber.d.ts

@@ -2,7 +2,7 @@
 import { Connection } from '@solana/web3.js';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types/types/src';
-declare type SlotSubscriberConfig = {};
+type SlotSubscriberConfig = {};
 export interface SlotSubscriberEvents {
     newSlot: (newSlot: number) => void;
 }

package/lib/testClient.d.ts

@@ -0,0 +1,8 @@
+import { AdminClient } from './adminClient';
+import { ConfirmOptions, Signer, Transaction } from '@solana/web3.js';
+import { TxSigAndSlot } from './tx/types';
+import { DriftClientConfig } from './driftClientConfig';
+export declare class TestClient extends AdminClient {
+    constructor(config: DriftClientConfig);
+    sendTransaction(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
+}

package/lib/testClient.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestClient = void 0;
+const adminClient_1 = require("./adminClient");
+class TestClient extends adminClient_1.AdminClient {
+    constructor(config) {
+        if (config.accountSubscription.type !== 'polling') {
+            throw new Error('Test client must be polling');
+        }
+        super(config);
+    }
+    async sendTransaction(tx, additionalSigners, opts, preSigned) {
+        const { txSig, slot } = await super.sendTransaction(tx, additionalSigners, opts, preSigned);
+        let lastFetchedSlot = this.accountSubscriber.accountLoader.mostRecentSlot;
+        while (lastFetchedSlot < slot) {
+            await this.fetchAccounts();
+            lastFetchedSlot = this.accountSubscriber.accountLoader.mostRecentSlot;
+        }
+        return { txSig, slot };
+    }
+}
+exports.TestClient = TestClient;

package/lib/tx/retryTxSender.d.ts

@@ -2,7 +2,7 @@
 import { TxSender, TxSigAndSlot } from './types';
 import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection } from '@solana/web3.js';
 import { AnchorProvider } from '@project-serum/anchor';
-declare type ResolveReference = {
+type ResolveReference = {
     resolve?: () => void;
 };
 export declare class RetryTxSender implements TxSender {

package/lib/tx/types.d.ts

@@ -1,6 +1,6 @@
 import { Provider } from '@project-serum/anchor';
 import { ConfirmOptions, Signer, Transaction, TransactionSignature } from '@solana/web3.js';
-export declare type TxSigAndSlot = {
+export type TxSigAndSlot = {
     txSig: TransactionSignature;
     slot: number;
 };