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

package/src/accounts/pollingClearingHouseAccountSubscriber.ts

@@ -24,6 +24,8 @@ import { getClearingHouseStateAccountPublicKey } from '../addresses';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { capitalize } from './utils';
 import { ClearingHouseConfigType } from '../factory/clearingHouse';
+import { PublicKey } from '@solana/web3.js';
+import { CLEARING_HOUSE_STATE_ACCOUNTS } from '../constants/accounts';
 
 export class PollingClearingHouseAccountSubscriber
 	implements ClearingHouseAccountSubscriber
@@ -98,44 +100,38 @@ export class PollingClearingHouseAccountSubscriber
 			return;
 		}
 
-		const statePublicKey = await getClearingHouseStateAccountPublicKey(
-			this.program.programId
-		);
-
-		const state = (await this.program.account.state.fetch(
-			statePublicKey
-		)) as StateAccount;
+		const accounts = await this.getClearingHouseAccounts();
 
-		this.accountsToPoll.set(statePublicKey.toString(), {
+		this.accountsToPoll.set(accounts.state.toString(), {
 			key: 'state',
-			publicKey: statePublicKey,
+			publicKey: accounts.state,
 			eventType: 'stateAccountUpdate',
 		});
 
-		this.accountsToPoll.set(state.markets.toString(), {
+		this.accountsToPoll.set(accounts.markets.toString(), {
 			key: 'markets',
-			publicKey: state.markets,
+			publicKey: accounts.markets,
 			eventType: 'marketsAccountUpdate',
 		});
 
-		this.accountsToPoll.set(state.orderState.toString(), {
+		this.accountsToPoll.set(accounts.orderState.toString(), {
 			key: 'orderState',
-			publicKey: state.orderState,
+			publicKey: accounts.orderState,
 			eventType: 'orderStateAccountUpdate',
 		});
 
 		if (this.optionalExtraSubscriptions?.includes('tradeHistoryAccount')) {
-			this.accountsToPoll.set(state.tradeHistory.toString(), {
+			this.accountsToPoll.set(accounts.tradeHistory.toString(), {
 				key: 'tradeHistory',
-				publicKey: state.tradeHistory,
+				publicKey: accounts.tradeHistory,
 				eventType: 'tradeHistoryAccountUpdate',
 			});
 		}
 
 		if (this.optionalExtraSubscriptions?.includes('depositHistoryAccount')) {
-			this.accountsToPoll.set(state.depositHistory.toString(), {
+			this.accountsToPoll.set(accounts.depositHistory.toString(), {
 				key: 'depositHistory',
-				publicKey: state.depositHistory,
+				publicKey: accounts.depositHistory,
 				eventType: 'depositHistoryAccountUpdate',
 			});
 		}
@@ -143,9 +139,9 @@ export class PollingClearingHouseAccountSubscriber
 		if (
 			this.optionalExtraSubscriptions?.includes('fundingPaymentHistoryAccount')
 		) {
-			this.accountsToPoll.set(state.fundingPaymentHistory.toString(), {
+			this.accountsToPoll.set(accounts.fundingPaymentHistory.toString(), {
 				key: 'fundingPaymentHistory',
-				publicKey: state.fundingPaymentHistory,
+				publicKey: accounts.fundingPaymentHistory,
 				eventType: 'fundingPaymentHistoryAccountUpdate',
 			});
 		}
@@ -153,17 +149,17 @@ export class PollingClearingHouseAccountSubscriber
 		if (
 			this.optionalExtraSubscriptions?.includes('fundingRateHistoryAccount')
 		) {
-			this.accountsToPoll.set(state.fundingRateHistory.toString(), {
+			this.accountsToPoll.set(accounts.fundingRateHistory.toString(), {
 				key: 'fundingRateHistory',
-				publicKey: state.fundingRateHistory,
+				publicKey: accounts.fundingRateHistory,
 				eventType: 'fundingRateHistoryAccountUpdate',
 			});
 		}
 
 		if (this.optionalExtraSubscriptions?.includes('curveHistoryAccount')) {
-			this.accountsToPoll.set(state.extendedCurveHistory.toString(), {
+			this.accountsToPoll.set(accounts.extendedCurveHistory.toString(), {
 				key: 'extendedCurveHistory',
-				publicKey: state.extendedCurveHistory,
+				publicKey: accounts.extendedCurveHistory,
 				eventType: 'curveHistoryAccountUpdate',
 			});
 		}
@@ -171,24 +167,58 @@ export class PollingClearingHouseAccountSubscriber
 		if (
 			this.optionalExtraSubscriptions?.includes('liquidationHistoryAccount')
 		) {
-			this.accountsToPoll.set(state.liquidationHistory.toString(), {
+			this.accountsToPoll.set(accounts.liquidationHistory.toString(), {
 				key: 'liquidationHistory',
-				publicKey: state.liquidationHistory,
+				publicKey: accounts.liquidationHistory,
 				eventType: 'liquidationHistoryAccountUpdate',
 			});
 		}
 
+		if (this.optionalExtraSubscriptions?.includes('orderHistoryAccount')) {
+			this.accountsToPoll.set(accounts.orderHistory.toString(), {
+				key: 'orderHistory',
+				publicKey: accounts.orderHistory,
+				eventType: 'orderHistoryAccountUpdate',
+			});
+		}
+	}
+
+	async getClearingHouseAccounts(): Promise<ClearingHouseAccounts> {
+		// Skip extra calls to rpc if we already know all the accounts
+		if (CLEARING_HOUSE_STATE_ACCOUNTS[this.program.programId.toString()]) {
+			return CLEARING_HOUSE_STATE_ACCOUNTS[this.program.programId.toString()];
+		}
+
+		const statePublicKey = await getClearingHouseStateAccountPublicKey(
+			this.program.programId
+		);
+
+		const state = (await this.program.account.state.fetch(
+			statePublicKey
+		)) as StateAccount;
+
+		const accounts = {
+			state: statePublicKey,
+			markets: state.markets,
+			orderState: state.orderState,
+			tradeHistory: state.tradeHistory,
+			depositHistory: state.depositHistory,
+			fundingPaymentHistory: state.fundingPaymentHistory,
+			fundingRateHistory: state.fundingRateHistory,
+			extendedCurveHistory: state.extendedCurveHistory,
+			liquidationHistory: state.liquidationHistory,
+			orderHistory: undefined,
+		};
+
 		if (this.optionalExtraSubscriptions?.includes('orderHistoryAccount')) {
 			const orderState = (await this.program.account.orderState.fetch(
 				state.orderState
 			)) as OrderStateAccount;
 
-			this.accountsToPoll.set(orderState.orderHistory.toString(), {
-				key: 'orderHistory',
-				publicKey: orderState.orderHistory,
-				eventType: 'orderHistoryAccountUpdate',
-			});
+			accounts.orderHistory = orderState.orderHistory;
 		}
+
+		return accounts;
 	}
 
 	async addToAccountLoader(): Promise<void> {
@@ -324,3 +354,16 @@ export class PollingClearingHouseAccountSubscriber
 		return this.orderHistory;
 	}
 }
+
+type ClearingHouseAccounts = {
+	state: PublicKey;
+	markets: PublicKey;
+	orderState: PublicKey;
+	tradeHistory?: PublicKey;
+	depositHistory?: PublicKey;
+	fundingPaymentHistory?: PublicKey;
+	fundingRateHistory?: PublicKey;
+	extendedCurveHistory?: PublicKey;
+	liquidationHistory?: PublicKey;
+	orderHistory?: PublicKey;
+};

package/src/clearingHouse.ts

@@ -543,19 +543,6 @@ export class ClearingHouse {
 		return [txSig, userAccountPublicKey];
 	}
 
-	public async deleteUser(): Promise<TransactionSignature> {
-		const userAccountPublicKey = await this.getUserAccountPublicKey();
-		const user = await this.program.account.user.fetch(userAccountPublicKey);
-		const deleteUserTx = await this.program.transaction.deleteUser({
-			accounts: {
-				user: userAccountPublicKey,
-				userPositions: user.positions,
-				authority: this.wallet.publicKey,
-			},
-		});
-		return this.txSender.send(deleteUserTx, [], this.opts);
-	}
-
 	public async withdrawCollateral(
 		amount: BN,
 		collateralAccountPublicKey: PublicKey

package/src/constants/accounts.ts

@@ -0,0 +1,26 @@
+import { PublicKey } from '@solana/web3.js';
+
+export const CLEARING_HOUSE_STATE_ACCOUNTS = {
+	dammHkt7jmytvbS3nHTxQNEcP59aE57nxwV21YdqEDN: {
+		state: new PublicKey('FExhvPycCCwYnZGeDsVtLhpEQ3yEkVY2k1HuPyfLj91L'),
+		markets: new PublicKey('773hq3SbGPKVj93TXi5qV5CREuhxobywfALjS3XVHhLH'),
+		orderState: new PublicKey('4cC34bWwTPGncBaX2S6v5mH3Lj4Nb3byPMrxQSDcY985'),
+		tradeHistory: new PublicKey('FCuCXEoQppoaCYdttA7rK3HNQfYkTNEGpwuBESzYcENp'),
+		depositHistory: new PublicKey(
+			'C7rF2Qy2rnDGQLRijBRRArJyaeuQcFi81BXDrUCQ45ya'
+		),
+		fundingPaymentHistory: new PublicKey(
+			'895iPhzwT2tBufLnRpYtBG3gif1HDDUfpH2AqbS5joo4'
+		),
+		fundingRateHistory: new PublicKey(
+			'BWiJLMbmrwfqHVpcPJa8715XamNyNYamDDKQVQMnduEC'
+		),
+		extendedCurveHistory: new PublicKey(
+			'7vBbqvMdtZLQdTVdzt5y63pZdAFE5W42kP3avngSJKCk'
+		),
+		liquidationHistory: new PublicKey(
+			'CSFaaf8yVoTx6NcXUKtNPYAewv76CH2jATqSVRBvUWKM'
+		),
+		orderHistory: new PublicKey('DZ7XfUqyHoRKnJLRApxmJ943xHJ7NDBUTqpbooviEtbU'),
+	},
+};

package/src/factory/clearingHouse.ts

@@ -10,6 +10,7 @@ import { DefaultTxSender } from '../tx/defaultTxSender';
 import { ClearingHouseAccountSubscriber } from '../accounts/types';
 import { PollingClearingHouseAccountSubscriber } from '../accounts/pollingClearingHouseAccountSubscriber';
 import { Admin } from '../admin';
+import { RetryTxSender } from '../tx/retryTxSender';
 
 export type ClearingHouseConfigType = 'websocket' | 'polling' | 'custom';
 
@@ -19,7 +20,7 @@ type BaseClearingHouseConfig = {
 	wallet: IWallet;
 	programID: PublicKey;
 	opts?: ConfirmOptions;
-	txSender?: TxSender;
+	txSenderConfig?: TxSenderConfig;
 };
 
 type WebSocketClearingHouseConfiguration = BaseClearingHouseConfig;
@@ -32,12 +33,28 @@ type ClearingHouseConfig =
 	| PollingClearingHouseConfiguration
 	| WebSocketClearingHouseConfiguration;
 
+export type TxSenderType = 'default' | 'retry';
+
+type BaseTxSenderConfig = {
+	type: TxSenderType;
+};
+
+type DefaultTxSenderConfig = BaseTxSenderConfig;
+
+type RetryTxSenderConfig = BaseTxSenderConfig & {
+	timeout?: number;
+	retrySleep?: number;
+	additionalConnections?: Connection[];
+};
+
+type TxSenderConfig = DefaultTxSenderConfig | RetryTxSenderConfig;
+
 export function getWebSocketClearingHouseConfig(
 	connection: Connection,
 	wallet: IWallet,
 	programID: PublicKey,
 	opts: ConfirmOptions = Provider.defaultOptions(),
-	txSender?: TxSender
+	txSenderConfig?: TxSenderConfig
 ): WebSocketClearingHouseConfiguration {
 	return {
 		type: 'websocket',
@@ -45,7 +62,7 @@ export function getWebSocketClearingHouseConfig(
 		wallet,
 		programID,
 		opts,
-		txSender,
+		txSenderConfig,
 	};
 }
 
@@ -55,7 +72,7 @@ export function getPollingClearingHouseConfig(
 	programID: PublicKey,
 	accountLoader: BulkAccountLoader,
 	opts: ConfirmOptions = Provider.defaultOptions(),
-	txSender?: TxSender
+	txSenderConfig?: TxSenderConfig
 ): PollingClearingHouseConfiguration {
 	return {
 		type: 'polling',
@@ -64,7 +81,7 @@ export function getPollingClearingHouseConfig(
 		programID,
 		accountLoader,
 		opts,
-		txSender,
+		txSenderConfig,
 	};
 }
 
@@ -85,7 +102,19 @@ export function getClearingHouse(config: ClearingHouseConfig): ClearingHouse {
 		);
 	}
 
-	const txSender = config.txSender || new DefaultTxSender(provider);
+	let txSender: TxSender;
+	if (config.txSenderConfig?.type === 'retry') {
+		const txSenderConfig = config.txSenderConfig as RetryTxSenderConfig;
+		txSender = new RetryTxSender(
+			provider,
+			txSenderConfig.timeout,
+			txSenderConfig.retrySleep,
+			txSenderConfig.additionalConnections
+		);
+	} else {
+		txSender = new DefaultTxSender(provider);
+	}
+
 	return new ClearingHouse(
 		config.connection,
 		config.wallet,
@@ -113,7 +142,18 @@ export function getAdmin(config: ClearingHouseConfig): Admin {
 		);
 	}
 
-	const txSender = config.txSender || new DefaultTxSender(provider);
+	let txSender: TxSender;
+	if (config.txSenderConfig?.type === 'retry') {
+		const txSenderConfig = config.txSenderConfig as RetryTxSenderConfig;
+		txSender = new RetryTxSender(
+			provider,
+			txSenderConfig.timeout,
+			txSenderConfig.retrySleep,
+			txSenderConfig.additionalConnections
+		);
+	} else {
+		txSender = new DefaultTxSender(provider);
+	}
 	return new Admin(
 		config.connection,
 		config.wallet,

package/src/idl/clearing_house.json

@@ -1482,32 +1482,6 @@
         }
       ]
     },
-    {
-      "name": "deleteUser",
-      "accounts": [
-        {
-          "name": "user",
-          "isMut": true,
-          "isSigner": false
-        },
-        {
-          "name": "userPositions",
-          "isMut": true,
-          "isSigner": false
-        },
-        {
-          "name": "userOrders",
-          "isMut": true,
-          "isSigner": false
-        },
-        {
-          "name": "authority",
-          "isMut": false,
-          "isSigner": true
-        }
-      ],
-      "args": []
-    },
     {
       "name": "settleFundingPayment",
       "accounts": [
@@ -3292,8 +3266,8 @@
             "type": "u128"
           },
           {
-            "name": "netRevenueSinceLastFunding",
-            "type": "i64"
+            "name": "padding1",
+            "type": "u64"
           },
           {
             "name": "padding2",
@@ -4300,11 +4274,6 @@
       "code": 6060,
       "name": "CantExpireOrders",
       "msg": "CantExpireOrders"
-    },
-    {
-      "code": 6061,
-      "name": "InvalidRepegPriceImpact",
-      "msg": "AMM repeg mark price impact vs oracle too large"
     }
   ]
 }

package/src/index.ts

@@ -29,7 +29,6 @@ export * from './math/position';
 export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';
-export * from './math/repeg';
 export * from './orders';
 export * from './orderParams';
 export * from './wallet';

package/src/math/amm.ts

@@ -4,7 +4,11 @@ import {
 	MARK_PRICE_PRECISION,
 	PEG_PRECISION,
 	ZERO,
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	QUOTE_PRECISION,
+	AMM_RESERVE_PRECISION,
 } from '../constants/numericConstants';
+import { calculateBaseAssetValue } from './position';
 import {
 	AMM,
 	PositionDirection,
@@ -13,7 +17,12 @@ import {
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
-import { squareRootBN } from '..';
+import {
+	calculatePositionPNL,
+	calculateMarkPrice,
+	convertToNumber,
+	squareRootBN,
+} from '..';
 
 /**
  * Calculates a price given an arbitrary base and quote amount (they must have the same precision)
@@ -130,6 +139,125 @@ export function getSwapDirection(
 	return SwapDirection.ADD;
 }
 
+/**
+ * Helper function calculating adjust k cost
+ * @param market
+ * @param marketIndex
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateAdjustKCost(
+	market: Market,
+	marketIndex: BN,
+	numerator: BN,
+	denomenator: BN
+): BN {
+	const netUserPosition = {
+		baseAssetAmount: market.baseAssetAmount,
+		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+		marketIndex: new BN(marketIndex),
+		quoteAssetAmount: new BN(0),
+		openOrders: new BN(0),
+	};
+
+	const currentValue = 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 = calculatePositionPNL(marketNewK, netUserPosition);
+
+	const p = 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 = PEG_PRECISION.sub(p).mul(y).div(PEG_PRECISION);
+	const numer20 = k
+		.mul(p)
+		.mul(p)
+		.div(PEG_PRECISION)
+		.div(PEG_PRECISION)
+		.div(x.mul(p).div(PEG_PRECISION).add(delta));
+	const numer21 = k.div(x.add(delta));
+
+	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));
+
+	// p.div(p.mul(x).add(delta)).sub()
+
+	return cost;
+}
+
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param market
+ * @param marketIndex
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export function calculateRepegCost(
+	market: Market,
+	marketIndex: BN,
+	newPeg: BN
+): BN {
+	const netUserPosition = {
+		baseAssetAmount: market.baseAssetAmount,
+		lastCumulativeFundingRate: market.amm.cumulativeFundingRate,
+		marketIndex: new BN(marketIndex),
+		quoteAssetAmount: new BN(0),
+		openOrders: new BN(0),
+	};
+
+	const currentValue = calculateBaseAssetValue(market, netUserPosition);
+	netUserPosition.quoteAssetAmount = currentValue;
+	const prevMarketPrice = 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',
+		convertToNumber(prevMarketPrice),
+		'to',
+		convertToNumber(calculateMarkPrice(marketNewPeg))
+	);
+
+	const cost = 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(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+	console.log(convertToNumber(cost2, QUOTE_PRECISION));
+	return cost;
+}
+
 /**
  * Helper function calculating terminal price of amm
  *
@@ -187,3 +315,86 @@ export function calculateMaxBaseAssetAmountToTrade(
 		return [new BN(0), PositionDirection.LONG];
 	}
 }
+
+export function calculateBudgetedK(market: Market, cost: BN): [BN, BN] {
+	// 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 BN(-1));
+
+	const numer1 = y.mul(d).mul(Q).div(AMM_RESERVE_PRECISION).div(PEG_PRECISION);
+	const numer2 = C.mul(x.add(d)).div(QUOTE_PRECISION);
+	const denom1 = C.mul(x)
+		.mul(x.add(d))
+		.div(AMM_RESERVE_PRECISION)
+		.div(QUOTE_PRECISION);
+	const denom2 = y
+		.mul(d)
+		.mul(d)
+		.mul(Q)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_RESERVE_PRECISION)
+		.div(PEG_PRECISION);
+
+	const numerator = d
+		.mul(numer1.add(numer2))
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_RESERVE_PRECISION)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO);
+	const denominator = denom1
+		.add(denom2)
+		.div(AMM_RESERVE_PRECISION)
+		.div(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];
+}
+
+export function calculateBudgetedPeg(market: Market, cost: BN): BN {
+	// 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 BN(-1));
+
+	const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
+	const deltaPegMultiplier = C.mul(MARK_PRICE_PRECISION)
+		.div(deltaQuoteAssetReserves.div(AMM_TO_QUOTE_PRECISION_RATIO))
+		.mul(PEG_PRECISION)
+		.div(QUOTE_PRECISION);
+	console.log(
+		Q.toNumber(),
+		'change by',
+		deltaPegMultiplier.toNumber() / MARK_PRICE_PRECISION.toNumber()
+	);
+	const newPeg = Q.sub(
+		deltaPegMultiplier.mul(PEG_PRECISION).div(MARK_PRICE_PRECISION)
+	);
+
+	return newPeg;
+}

package/src/tx/retryTxSender.ts

@@ -8,6 +8,7 @@ import {
 	SignatureResult,
 	Transaction,
 	TransactionSignature,
+	Connection,
 } from '@solana/web3.js';
 import { Provider } from '@project-serum/anchor';
 import assert from 'assert';
@@ -24,15 +25,18 @@ export class RetryTxSender implements TxSender {
 	provider: Provider;
 	timeout: number;
 	retrySleep: number;
+	additionalConnections: Connection[];
 
 	public constructor(
 		provider: Provider,
 		timeout?: number,
-		retrySleep?: number
+		retrySleep?: number,
+		additionalConnections = new Array<Connection>()
 	) {
 		this.provider = provider;
 		this.timeout = timeout ?? DEFAULT_TIMEOUT;
 		this.retrySleep = retrySleep ?? DEFAULT_RETRY;
+		this.additionalConnections = additionalConnections;
 	}
 
 	async send(
@@ -54,6 +58,7 @@ export class RetryTxSender implements TxSender {
 
 		const txid: TransactionSignature =
 			await this.provider.connection.sendRawTransaction(rawTransaction, opts);
+		this.sendToAdditionalConnections(rawTransaction, opts);
 
 		let done = false;
 		const resolveReference: ResolveReference = {
@@ -76,6 +81,7 @@ export class RetryTxSender implements TxSender {
 							console.error(e);
 							stopWaiting();
 						});
+					this.sendToAdditionalConnections(rawTransaction, opts);
 				}
 			}
 		})();
@@ -193,4 +199,16 @@ export class RetryTxSender implements TxSender {
 			return result;
 		});
 	}
+
+	sendToAdditionalConnections(rawTx: Buffer, opts: ConfirmOptions): void {
+		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);
+			});
+		});
+	}
 }