@drift-labs/sdk 0.1.29 → 0.1.30-master.2

package/lib/math/amm.d.ts

@@ -38,6 +38,24 @@ export declare function calculateSwapOutput(inputAssetReserve: BN, swapAmount: B
  * @param positionDirection
  */
 export declare function getSwapDirection(inputAssetType: AssetType, positionDirection: PositionDirection): SwapDirection;
+/**
+ * Helper function calculating adjust k cost
+ * @param market
+ * @param marketIndex
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export declare function calculateAdjustKCost(market: Market, marketIndex: BN, numerator: BN, denomenator: BN): BN;
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param market
+ * @param marketIndex
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export declare function calculateRepegCost(market: Market, marketIndex: BN, newPeg: BN): BN;
 /**
  * Helper function calculating terminal price of amm
  *
@@ -46,3 +64,5 @@ export declare function getSwapDirection(inputAssetType: AssetType, positionDire
  */
 export declare function calculateTerminalPrice(market: Market): BN;
 export declare function calculateMaxBaseAssetAmountToTrade(amm: AMM, limit_price: BN): [BN, PositionDirection];
+export declare function calculateBudgetedK(market: Market, cost: BN): [BN, BN];
+export declare function calculateBudgetedPeg(market: Market, cost: BN): BN;

package/lib/math/amm.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = void 0;
+exports.calculateBudgetedPeg = exports.calculateBudgetedK = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.calculateRepegCost = exports.calculateAdjustKCost = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
+const position_1 = require("./position");
 const types_1 = require("../types");
 const assert_1 = require("../assert/assert");
 const __1 = require("..");
@@ -87,6 +88,92 @@ function getSwapDirection(inputAssetType, positionDirection) {
     return types_1.SwapDirection.ADD;
 }
 exports.getSwapDirection = getSwapDirection;
+/**
+ * Helper function calculating adjust k cost
+ * @param market
+ * @param marketIndex
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+function calculateAdjustKCost(market, marketIndex, numerator, denomenator) {
+    const netUserPosition = {
+        baseAssetAmount: market.baseAssetAmount,
+        lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+        marketIndex: new anchor_1.BN(marketIndex),
+        quoteAssetAmount: new anchor_1.BN(0),
+        openOrders: new anchor_1.BN(0),
+    };
+    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
+    const marketNewK = Object.assign({}, market);
+    marketNewK.amm = Object.assign({}, market.amm);
+    marketNewK.amm.baseAssetReserve = market.amm.baseAssetReserve
+        .mul(numerator)
+        .div(denomenator);
+    marketNewK.amm.quoteAssetReserve = market.amm.quoteAssetReserve
+        .mul(numerator)
+        .div(denomenator);
+    marketNewK.amm.sqrtK = market.amm.sqrtK.mul(numerator).div(denomenator);
+    netUserPosition.quoteAssetAmount = currentValue;
+    const cost = (0, __1.calculatePositionPNL)(marketNewK, netUserPosition);
+    const p = numericConstants_1.PEG_PRECISION.mul(numerator).div(denomenator);
+    const x = market.amm.baseAssetReserve;
+    const y = market.amm.quoteAssetReserve;
+    const delta = market.baseAssetAmount;
+    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const numer1 = numericConstants_1.PEG_PRECISION.sub(p).mul(y).div(numericConstants_1.PEG_PRECISION);
+    const numer20 = k
+        .mul(p)
+        .mul(p)
+        .div(numericConstants_1.PEG_PRECISION)
+        .div(numericConstants_1.PEG_PRECISION)
+        .div(x.mul(p).div(numericConstants_1.PEG_PRECISION).add(delta));
+    const numer21 = k.div(x.add(delta));
+    const formulaCost = numer21
+        .sub(numer20)
+        .sub(numer1)
+        .mul(market.amm.pegMultiplier)
+        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    console.log((0, __1.convertToNumber)(formulaCost, numericConstants_1.QUOTE_PRECISION));
+    // p.div(p.mul(x).add(delta)).sub()
+    return cost;
+}
+exports.calculateAdjustKCost = calculateAdjustKCost;
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param market
+ * @param marketIndex
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+function calculateRepegCost(market, marketIndex, newPeg) {
+    const netUserPosition = {
+        baseAssetAmount: market.baseAssetAmount,
+        lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+        marketIndex: new anchor_1.BN(marketIndex),
+        quoteAssetAmount: new anchor_1.BN(0),
+        openOrders: new anchor_1.BN(0),
+    };
+    const currentValue = (0, position_1.calculateBaseAssetValue)(market, netUserPosition);
+    netUserPosition.quoteAssetAmount = currentValue;
+    const prevMarketPrice = (0, __1.calculateMarkPrice)(market);
+    const marketNewPeg = Object.assign({}, market);
+    marketNewPeg.amm = Object.assign({}, market.amm);
+    // const marketNewPeg = JSON.parse(JSON.stringify(market));
+    marketNewPeg.amm.pegMultiplier = newPeg;
+    console.log('Price moves from', (0, __1.convertToNumber)(prevMarketPrice), 'to', (0, __1.convertToNumber)((0, __1.calculateMarkPrice)(marketNewPeg)));
+    const cost = (0, __1.calculatePositionPNL)(marketNewPeg, netUserPosition);
+    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const newQuoteAssetReserve = k.div(market.amm.baseAssetReserve.add(netUserPosition.baseAssetAmount));
+    const deltaQuoteAssetReserves = newQuoteAssetReserve.sub(market.amm.quoteAssetReserve);
+    const cost2 = deltaQuoteAssetReserves
+        .mul(market.amm.pegMultiplier.sub(newPeg))
+        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    console.log((0, __1.convertToNumber)(cost2, numericConstants_1.QUOTE_PRECISION));
+    return cost;
+}
+exports.calculateRepegCost = calculateRepegCost;
 /**
  * Helper function calculating terminal price of amm
  *
@@ -132,3 +219,66 @@ function calculateMaxBaseAssetAmountToTrade(amm, limit_price) {
     }
 }
 exports.calculateMaxBaseAssetAmountToTrade = calculateMaxBaseAssetAmountToTrade;
+function calculateBudgetedK(market, cost) {
+    // 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
+    // const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const x = market.amm.baseAssetReserve;
+    const y = market.amm.quoteAssetReserve;
+    const d = market.baseAssetAmount;
+    const Q = market.amm.pegMultiplier;
+    const C = cost.mul(new anchor_1.BN(-1));
+    const numer1 = y.mul(d).mul(Q).div(numericConstants_1.AMM_RESERVE_PRECISION).div(numericConstants_1.PEG_PRECISION);
+    const numer2 = C.mul(x.add(d)).div(numericConstants_1.QUOTE_PRECISION);
+    const denom1 = C.mul(x)
+        .mul(x.add(d))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.QUOTE_PRECISION);
+    const denom2 = y
+        .mul(d)
+        .mul(d)
+        .mul(Q)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.PEG_PRECISION);
+    const numerator = d
+        .mul(numer1.add(numer2))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    const denominator = denom1
+        .add(denom2)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    console.log(numerator, denominator);
+    // const p = (numerator).div(denominator);
+    // const formulaCost = (numer21.sub(numer20).sub(numer1)).mul(market.amm.pegMultiplier).div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+    // console.log(convertToNumber(formulaCost, QUOTE_PRECISION))
+    return [numerator, denominator];
+}
+exports.calculateBudgetedK = calculateBudgetedK;
+function calculateBudgetedPeg(market, cost) {
+    // 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
+    const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+    const x = market.amm.baseAssetReserve;
+    const y = market.amm.quoteAssetReserve;
+    const d = market.baseAssetAmount;
+    const Q = market.amm.pegMultiplier;
+    const C = cost.mul(new anchor_1.BN(-1));
+    const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
+    const deltaPegMultiplier = C.mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO))
+        .mul(numericConstants_1.PEG_PRECISION)
+        .div(numericConstants_1.QUOTE_PRECISION);
+    console.log(Q.toNumber(), 'change by', deltaPegMultiplier.toNumber() / numericConstants_1.MARK_PRICE_PRECISION.toNumber());
+    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.MARK_PRICE_PRECISION));
+    return newPeg;
+}
+exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/lib/tx/retryTxSender.d.ts

@@ -1,5 +1,6 @@
+/// <reference types="node" />
 import { TxSender } from './types';
-import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature } from '@solana/web3.js';
+import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection } from '@solana/web3.js';
 import { Provider } from '@project-serum/anchor';
 declare type ResolveReference = {
     resolve?: () => void;
@@ -8,12 +9,14 @@ export declare class RetryTxSender implements TxSender {
     provider: Provider;
     timeout: number;
     retrySleep: number;
-    constructor(provider: Provider, timeout?: number, retrySleep?: number);
+    additionalConnections: Connection[];
+    constructor(provider: Provider, timeout?: number, retrySleep?: number, additionalConnections?: Connection[]);
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<TransactionSignature>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
     confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
     getTimestamp(): number;
     sleep(reference: ResolveReference): Promise<void>;
     promiseTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | null>;
+    sendToAdditionalConnections(rawTx: Buffer, opts: ConfirmOptions): void;
 }
 export {};

package/lib/tx/retryTxSender.js

@@ -18,10 +18,11 @@ const bs58_1 = __importDefault(require("bs58"));
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 8000;
 class RetryTxSender {
-    constructor(provider, timeout, retrySleep) {
+    constructor(provider, timeout, retrySleep, additionalConnections = new Array()) {
         this.provider = provider;
         this.timeout = timeout !== null && timeout !== void 0 ? timeout : DEFAULT_TIMEOUT;
         this.retrySleep = retrySleep !== null && retrySleep !== void 0 ? retrySleep : DEFAULT_RETRY;
+        this.additionalConnections = additionalConnections;
     }
     send(tx, additionalSigners, opts) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -35,6 +36,7 @@ class RetryTxSender {
             const rawTransaction = tx.serialize();
             const startTime = this.getTimestamp();
             const txid = yield this.provider.connection.sendRawTransaction(rawTransaction, opts);
+            this.sendToAdditionalConnections(rawTransaction, opts);
             let done = false;
             const resolveReference = {
                 resolve: undefined,
@@ -55,6 +57,7 @@ class RetryTxSender {
                             console.error(e);
                             stopWaiting();
                         });
+                        this.sendToAdditionalConnections(rawTransaction, opts);
                     }
                 }
             }))();
@@ -149,5 +152,15 @@ class RetryTxSender {
             return result;
         });
     }
+    sendToAdditionalConnections(rawTx, opts) {
+        this.additionalConnections.map((connection) => {
+            connection.sendRawTransaction(rawTx, opts).catch((e) => {
+                console.error(
+                // @ts-ignore
+                `error sending tx to additional connection ${connection._rpcEndpoint}`);
+                console.error(e);
+            });
+        });
+    }
 }
 exports.RetryTxSender = RetryTxSender;

package/lib/util/promiseTimeout.d.ts

@@ -0,0 +1 @@
+export declare function promiseTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | null>;

package/lib/util/promiseTimeout.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTimeout = void 0;
+function promiseTimeout(promise, timeoutMs) {
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => resolve(null), timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).then((result) => {
+        clearTimeout(timeoutId);
+        return result;
+    });
+}
+exports.promiseTimeout = promiseTimeout;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.29",
+	"version": "0.1.30-master.2",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/bulkAccountLoader.ts

@@ -1,6 +1,7 @@
 import { Commitment, Connection, PublicKey } from '@solana/web3.js';
 import { v4 as uuidv4 } from 'uuid';
 import { AccountData } from './types';
+import { promiseTimeout } from '../util/promiseTimeout';
 
 type AccountToLoad = {
 	publicKey: PublicKey;
@@ -10,7 +11,6 @@ type AccountToLoad = {
 const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
 
 const oneMinute = 60 * 1000;
-const fiveMinutes = 5 * 60 * 1000;
 
 export class BulkAccountLoader {
 	connection: Connection;
@@ -24,7 +24,7 @@ export class BulkAccountLoader {
 	loadPromise?: Promise<void>;
 	loadPromiseResolver: () => void;
 	loggingEnabled = false;
-	lastUpdate = Date.now();
+	lastTimeLoadingPromiseCleared = Date.now();
 
 	public constructor(
 		connection: Connection,
@@ -43,10 +43,15 @@ export class BulkAccountLoader {
 		const existingSize = this.accountsToLoad.size;
 
 		const callbackId = uuidv4();
+		this.log(
+			`Adding account ${publicKey.toString()} callback id ${callbackId}`
+		);
 		const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
 		if (existingAccountToLoad) {
+			this.log(`account already exists`);
 			existingAccountToLoad.callbacks.set(callbackId, callback);
 		} else {
+			this.log(`account doesn't already exist. creating new callback map`);
 			const callbacks = new Map<string, (buffer: Buffer) => void>();
 			callbacks.set(callbackId, callback);
 			const newAccountToLoad = {
@@ -67,6 +72,9 @@ export class BulkAccountLoader {
 	}
 
 	public removeAccount(publicKey: PublicKey, callbackId: string): void {
+		this.log(
+			`Removing account ${publicKey.toString()} callback id ${callbackId}`
+		);
 		const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
 		if (existingAccountToLoad) {
 			existingAccountToLoad.callbacks.delete(callbackId);
@@ -99,17 +107,29 @@ export class BulkAccountLoader {
 
 	public async load(): Promise<void> {
 		if (this.loadPromise) {
-			return this.loadPromise;
+			const now = Date.now();
+			if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
+				this.log(`Load promise hasnt been clearing for one minute. Clearing.`);
+				this.loadPromise = undefined;
+			} else {
+				this.log(`Load promise exists. Returning early`);
+				return this.loadPromise;
+			}
 		}
+
 		this.loadPromise = new Promise((resolver) => {
 			this.loadPromiseResolver = resolver;
 		});
+		this.lastTimeLoadingPromiseCleared = Date.now();
+
+		this.log(`Loading`);
 
 		try {
 			const chunks = this.chunks(
 				Array.from(this.accountsToLoad.values()),
 				GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE
 			);
+			this.log(`${chunks.length} chunks`);
 
 			await Promise.all(
 				chunks.map((chunk) => {
@@ -122,28 +142,17 @@ export class BulkAccountLoader {
 			for (const [_, callback] of this.errorCallbacks) {
 				callback(e);
 			}
+			this.log('finished error callbacks');
 		} finally {
+			this.log(`resetting load promise`);
 			this.loadPromiseResolver();
 			this.loadPromise = undefined;
-
-			const now = Date.now();
-			if (now - this.lastUpdate > fiveMinutes) {
-				if (this.loggingEnabled) {
-					console.log(
-						"Haven't seen updated account in five minutes. Bulk account loader creating new Connection Object"
-					);
-				}
-				this.connection = new Connection(
-					// @ts-ignore
-					this.connection._rpcEndpoint,
-					this.connection.commitment
-				);
-			}
 		}
 	}
 
 	async loadChunk(accountsToLoad: AccountToLoad[]): Promise<void> {
 		if (accountsToLoad.length === 0) {
+			this.log(`no accounts in chunk`);
 			return;
 		}
 
@@ -154,15 +163,15 @@ export class BulkAccountLoader {
 			{ commitment: this.commitment },
 		];
 
-		// @ts-ignore
-		const rpcResponse = await this.connection._rpcRequest(
-			'getMultipleAccounts',
-			args
+		const rpcResponse: any | null = await promiseTimeout(
+			// @ts-ignore
+			this.connection._rpcRequest('getMultipleAccounts', args),
+			10 * 1000 // 30 second timeout
 		);
 
-		const oneMinuteSinceLastUpdate = Date.now() - this.lastUpdate > oneMinute;
-		if (this.loggingEnabled && oneMinuteSinceLastUpdate) {
-			console.log('rpcResponse', JSON.stringify(rpcResponse));
+		if (rpcResponse === null) {
+			this.log('request to rpc timed out', true);
+			return;
 		}
 
 		const newSlot = rpcResponse.result.context.slot;
@@ -179,44 +188,44 @@ export class BulkAccountLoader {
 				newBuffer = Buffer.from(raw, dataType);
 			}
 
-			if (this.loggingEnabled && oneMinuteSinceLastUpdate) {
-				console.log('oldRPCResponse', oldRPCResponse);
-			}
-
 			if (!oldRPCResponse) {
+				this.log('No old rpc response, updating account data');
 				this.accountData.set(key, {
 					slot: newSlot,
 					buffer: newBuffer,
 				});
 				this.handleAccountCallbacks(accountToLoad, newBuffer);
-				this.lastUpdate = Date.now();
 				continue;
 			}
 
 			if (newSlot <= oldRPCResponse.slot) {
+				this.log(`new slot ${newSlot} old slot ${oldRPCResponse.slot}`);
 				continue;
 			}
 
 			const oldBuffer = oldRPCResponse.buffer;
 			if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+				this.log('new buffer, updating account data');
 				this.accountData.set(key, {
 					slot: newSlot,
 					buffer: newBuffer,
 				});
 				this.handleAccountCallbacks(accountToLoad, newBuffer);
-				this.lastUpdate = Date.now();
-			} else if (this.loggingEnabled) {
-				console.log('unable to update account for newest slot');
-				console.log('oldBuffer', oldBuffer);
-				console.log('newBuffer', newBuffer);
+			} else {
+				this.log('unable to update account for newest slot');
+				this.log('oldBuffer ' + oldBuffer);
+				this.log('newBuffer ' + newBuffer);
+				this.log('buffers equal ' + newBuffer?.equals(oldBuffer));
 			}
 		}
 	}
 
 	handleAccountCallbacks(accountToLoad: AccountToLoad, buffer: Buffer): void {
+		this.log('handling account callbacks');
 		for (const [_, callback] of accountToLoad.callbacks) {
 			callback(buffer);
 		}
+		this.log('finished account callbacks');
 	}
 
 	public getAccountData(publicKey: PublicKey): Buffer | undefined {
@@ -229,9 +238,7 @@ export class BulkAccountLoader {
 			return;
 		}
 
-		if (this.loggingEnabled) {
-			console.log(`startPolling`);
-		}
+		this.log('startPolling');
 
 		this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
 	}
@@ -241,9 +248,13 @@ export class BulkAccountLoader {
 			clearInterval(this.intervalId);
 			this.intervalId = undefined;
 
-			if (this.loggingEnabled) {
-				console.log(`stopPolling`);
-			}
+			this.log('stopPolling');
+		}
+	}
+
+	public log(msg: string, force = false): void {
+		if (this.loggingEnabled || force) {
+			console.log(msg);
 		}
 	}
 }