@drift-labs/sdk 0.2.0-master.11 → 0.2.0-master.14

package/src/mockUSDCFaucet.js

@@ -1,280 +0,0 @@
-'use strict';
-var __createBinding =
-	(this && this.__createBinding) ||
-	(Object.create
-		? function (o, m, k, k2) {
-				if (k2 === undefined) k2 = k;
-				Object.defineProperty(o, k2, {
-					enumerable: true,
-					get: function () {
-						return m[k];
-					},
-				});
-		  }
-		: function (o, m, k, k2) {
-				if (k2 === undefined) k2 = k;
-				o[k2] = m[k];
-		  });
-var __setModuleDefault =
-	(this && this.__setModuleDefault) ||
-	(Object.create
-		? function (o, v) {
-				Object.defineProperty(o, 'default', { enumerable: true, value: v });
-		  }
-		: function (o, v) {
-				o['default'] = v;
-		  });
-var __importStar =
-	(this && this.__importStar) ||
-	function (mod) {
-		if (mod && mod.__esModule) return mod;
-		var result = {};
-		if (mod != null)
-			for (var k in mod)
-				if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k))
-					__createBinding(result, mod, k);
-		__setModuleDefault(result, mod);
-		return result;
-	};
-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());
-		});
-	};
-var __importDefault =
-	(this && this.__importDefault) ||
-	function (mod) {
-		return mod && mod.__esModule ? mod : { default: mod };
-	};
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.MockUSDCFaucet = void 0;
-const anchor = __importStar(require('@project-serum/anchor'));
-const anchor_1 = require('@project-serum/anchor');
-const spl_token_1 = require('@solana/spl-token');
-const web3_js_1 = require('@solana/web3.js');
-const mock_usdc_faucet_json_1 = __importDefault(
-	require('./idl/token_faucet.json')
-);
-class MockUSDCFaucet {
-	constructor(connection, wallet, programId, opts) {
-		this.connection = connection;
-		this.wallet = wallet;
-		this.opts = opts || anchor_1.AnchorProvider.defaultOptions();
-		const provider = new anchor_1.AnchorProvider(connection, wallet, this.opts);
-		this.provider = provider;
-		this.program = new anchor_1.Program(
-			mock_usdc_faucet_json_1.default,
-			programId,
-			provider
-		);
-	}
-	getMockUSDCFaucetStatePublicKeyAndNonce() {
-		return __awaiter(this, void 0, void 0, function* () {
-			return anchor.web3.PublicKey.findProgramAddress(
-				[Buffer.from(anchor.utils.bytes.utf8.encode('mock_usdc_faucet'))],
-				this.program.programId
-			);
-		});
-	}
-	getMockUSDCFaucetStatePublicKey() {
-		return __awaiter(this, void 0, void 0, function* () {
-			if (this.mockUSDCFaucetStatePublicKey) {
-				return this.mockUSDCFaucetStatePublicKey;
-			}
-			this.mockUSDCFaucetStatePublicKey =
-				(yield this.getMockUSDCFaucetStatePublicKeyAndNonce())[0];
-			return this.mockUSDCFaucetStatePublicKey;
-		});
-	}
-	initialize() {
-		return __awaiter(this, void 0, void 0, function* () {
-			const stateAccountRPCResponse =
-				yield this.connection.getParsedAccountInfo(
-					yield this.getMockUSDCFaucetStatePublicKey()
-				);
-			if (stateAccountRPCResponse.value !== null) {
-				throw new Error('Faucet already initialized');
-			}
-			const fakeUSDCMint = anchor.web3.Keypair.generate();
-			const createUSDCMintAccountIx = web3_js_1.SystemProgram.createAccount({
-				fromPubkey: this.wallet.publicKey,
-				newAccountPubkey: fakeUSDCMint.publicKey,
-				lamports: yield spl_token_1.Token.getMinBalanceRentForExemptMint(
-					this.connection
-				),
-				space: spl_token_1.MintLayout.span,
-				programId: spl_token_1.TOKEN_PROGRAM_ID,
-			});
-			const [mintAuthority, _mintAuthorityNonce] =
-				yield web3_js_1.PublicKey.findProgramAddress(
-					[fakeUSDCMint.publicKey.toBuffer()],
-					this.program.programId
-				);
-			const initUSDCMintIx = spl_token_1.Token.createInitMintInstruction(
-				spl_token_1.TOKEN_PROGRAM_ID,
-				fakeUSDCMint.publicKey,
-				6,
-				mintAuthority,
-				null
-			);
-			const [mockUSDCFaucetStatePublicKey, mockUSDCFaucetStateNonce] =
-				yield this.getMockUSDCFaucetStatePublicKeyAndNonce();
-			return yield this.program.rpc.initialize(mockUSDCFaucetStateNonce, {
-				accounts: {
-					mockUsdcFaucetState: mockUSDCFaucetStatePublicKey,
-					admin: this.wallet.publicKey,
-					mintAccount: fakeUSDCMint.publicKey,
-					rent: web3_js_1.SYSVAR_RENT_PUBKEY,
-					systemProgram: anchor.web3.SystemProgram.programId,
-				},
-				instructions: [createUSDCMintAccountIx, initUSDCMintIx],
-				signers: [fakeUSDCMint],
-			});
-		});
-	}
-	fetchState() {
-		return __awaiter(this, void 0, void 0, function* () {
-			return yield this.program.account.mockUsdcFaucetState.fetch(
-				yield this.getMockUSDCFaucetStatePublicKey()
-			);
-		});
-	}
-	mintToUser(userTokenAccount, amount) {
-		return __awaiter(this, void 0, void 0, function* () {
-			const state = yield this.fetchState();
-			return yield this.program.rpc.mintToUser(amount, {
-				accounts: {
-					mockUsdcFaucetState: yield this.getMockUSDCFaucetStatePublicKey(),
-					mintAccount: state.mint,
-					userTokenAccount,
-					mintAuthority: state.mintAuthority,
-					tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-				},
-			});
-		});
-	}
-	createAssociatedTokenAccountAndMintTo(userPublicKey, amount) {
-		return __awaiter(this, void 0, void 0, function* () {
-			const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] =
-				yield this.createAssociatedTokenAccountAndMintToInstructions(
-					userPublicKey,
-					amount
-				);
-			const tx = new web3_js_1.Transaction()
-				.add(createAssociatedAccountIx)
-				.add(mintToTx);
-			const txSig = yield this.program.provider.sendAndConfirm(
-				tx,
-				[],
-				this.opts
-			);
-			return [associatedTokenPublicKey, txSig];
-		});
-	}
-	createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount) {
-		return __awaiter(this, void 0, void 0, function* () {
-			const state = yield this.fetchState();
-			const associateTokenPublicKey =
-				yield this.getAssosciatedMockUSDMintAddress({
-					userPubKey: userPublicKey,
-				});
-			const createAssociatedAccountIx =
-				spl_token_1.Token.createAssociatedTokenAccountInstruction(
-					spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
-					spl_token_1.TOKEN_PROGRAM_ID,
-					state.mint,
-					associateTokenPublicKey,
-					userPublicKey,
-					this.wallet.publicKey
-				);
-			const mintToIx = yield this.program.instruction.mintToUser(amount, {
-				accounts: {
-					mockUsdcFaucetState: yield this.getMockUSDCFaucetStatePublicKey(),
-					mintAccount: state.mint,
-					userTokenAccount: associateTokenPublicKey,
-					mintAuthority: state.mintAuthority,
-					tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-				},
-			});
-			return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
-		});
-	}
-	getAssosciatedMockUSDMintAddress(props) {
-		return __awaiter(this, void 0, void 0, function* () {
-			const state = yield this.fetchState();
-			return spl_token_1.Token.getAssociatedTokenAddress(
-				spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
-				spl_token_1.TOKEN_PROGRAM_ID,
-				state.mint,
-				props.userPubKey
-			);
-		});
-	}
-	getTokenAccountInfo(props) {
-		return __awaiter(this, void 0, void 0, function* () {
-			const assosciatedKey = yield this.getAssosciatedMockUSDMintAddress(props);
-			const state = yield this.fetchState();
-			const token = new spl_token_1.Token(
-				this.connection,
-				state.mint,
-				spl_token_1.TOKEN_PROGRAM_ID,
-				// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-				// @ts-ignore
-				this.provider.payer
-			);
-			return yield token.getAccountInfo(assosciatedKey);
-		});
-	}
-	subscribeToTokenAccount(props) {
-		return __awaiter(this, void 0, void 0, function* () {
-			try {
-				const tokenAccountKey = yield this.getAssosciatedMockUSDMintAddress(
-					props
-				);
-				props.callback(yield this.getTokenAccountInfo(props));
-				// Couldn't find a way to do it using anchor framework subscription, someone on serum discord recommended this way
-				this.connection.onAccountChange(
-					tokenAccountKey,
-					(
-						_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */
-					) =>
-						__awaiter(this, void 0, void 0, function* () {
-							props.callback(yield this.getTokenAccountInfo(props));
-						})
-				);
-				return true;
-			} catch (e) {
-				return false;
-			}
-		});
-	}
-}
-exports.MockUSDCFaucet = MockUSDCFaucet;

package/src/orders.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
-const types_1 = require("./types");
-const _1 = require(".");
-const market_1 = require("./math/market");
-const numericConstants_1 = require("./constants/numericConstants");
-const amm_1 = require("./math/amm");
-const position_1 = require("./math/position");
-function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
-    if (types_1.isVariant(order.status, 'init')) {
-        return null;
-    }
-    const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(market, order);
-    if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
-        return null;
-    }
-    const userAccountAfter = Object.assign({}, userAccount);
-    const userPositionAfter = Object.assign({}, userPosition);
-    const currentPositionDirection = position_1.positionCurrentDirection(userPosition);
-    const increasePosition = userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) ||
-        isSameDirection(order.direction, currentPositionDirection);
-    if (increasePosition) {
-        const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
-        const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(market, marketAfter);
-        userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
-        userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(quoteAssetAmountSwapped);
-        return [userAccountAfter, userPositionAfter, marketAfter];
-    }
-    else {
-        const reversePosition = baseAssetAmountToTrade.gt(userPosition.baseAssetAmount.abs());
-        if (reversePosition) {
-            const intermediateMarket = market_1.calculateNewMarketAfterTrade(userPosition.baseAssetAmount, position_1.findDirectionToClose(userPosition), market);
-            const { quoteAssetAmountSwapped: baseAssetValue } = calculateAmountSwapped(market, intermediateMarket);
-            let pnl;
-            if (types_1.isVariant(currentPositionDirection, 'long')) {
-                pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
-            }
-            else {
-                pnl = userPosition.quoteAssetAmount.sub(baseAssetValue);
-            }
-            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-            const baseAssetAmountLeft = baseAssetAmountToTrade.sub(userPosition.baseAssetAmount.abs());
-            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountLeft, order.direction, intermediateMarket);
-            const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(intermediateMarket, marketAfter);
-            userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
-            userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
-            return [userAccountAfter, userPositionAfter, marketAfter];
-        }
-        else {
-            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
-            const { quoteAssetAmountSwapped: baseAssetValue, baseAssetAmountSwapped, } = calculateAmountSwapped(market, marketAfter);
-            const costBasisRealized = userPosition.quoteAssetAmount
-                .mul(baseAssetAmountSwapped.abs())
-                .div(userPosition.baseAssetAmount.abs());
-            let pnl;
-            if (types_1.isVariant(currentPositionDirection, 'long')) {
-                pnl = baseAssetValue.sub(costBasisRealized);
-            }
-            else {
-                pnl = costBasisRealized.sub(baseAssetValue);
-            }
-            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-            userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
-            userPositionAfter.quoteAssetAmount =
-                userPositionAfter.quoteAssetAmount.sub(costBasisRealized);
-            return [userAccountAfter, userPositionAfter, marketAfter];
-        }
-    }
-}
-exports.calculateNewStateAfterOrder = calculateNewStateAfterOrder;
-function calculateAmountSwapped(marketBefore, marketAfter) {
-    return {
-        quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
-            .sub(marketAfter.amm.quoteAssetReserve)
-            .abs()
-            .mul(marketBefore.amm.pegMultiplier)
-            .div(numericConstants_1.PEG_PRECISION)
-            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO),
-        baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(marketAfter.amm.baseAssetReserve),
-    };
-}
-function calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData) {
-    if (types_1.isVariant(order.orderType, 'limit')) {
-        return calculateAmountToTradeForLimit(market, order, oraclePriceData);
-    }
-    else if (types_1.isVariant(order.orderType, 'triggerLimit')) {
-        return calculateAmountToTradeForTriggerLimit(market, order);
-    }
-    else if (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] = amm_1.calculateMaxBaseAssetAmountToTrade(market.amm, limitPrice, order.direction);
-    const baseAssetAmount = _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 ((types_1.isVariant(firstDirection, 'long') && types_1.isVariant(secondDirection, 'long')) ||
-        (types_1.isVariant(firstDirection, 'short') && types_1.isVariant(secondDirection, 'short')));
-}
-function calculateAmountToTradeForTriggerMarket(market, order) {
-    if (!order.triggered) {
-        return numericConstants_1.ZERO;
-    }
-    return order.baseAssetAmount;
-}

package/src/tx/retryTxSender.js

@@ -1,188 +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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RetryTxSender = void 0;
-const assert_1 = __importDefault(require("assert"));
-const bs58_1 = __importDefault(require("bs58"));
-const DEFAULT_TIMEOUT = 35000;
-const DEFAULT_RETRY = 8000;
-class RetryTxSender {
-    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* () {
-            if (additionalSigners === undefined) {
-                additionalSigners = [];
-            }
-            if (opts === undefined) {
-                opts = this.provider.opts;
-            }
-            yield this.prepareTx(tx, additionalSigners, opts);
-            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,
-            };
-            const stopWaiting = () => {
-                done = true;
-                if (resolveReference.resolve) {
-                    resolveReference.resolve();
-                }
-            };
-            (() => __awaiter(this, void 0, void 0, function* () {
-                while (!done && this.getTimestamp() - startTime < this.timeout) {
-                    yield this.sleep(resolveReference);
-                    if (!done) {
-                        this.provider.connection
-                            .sendRawTransaction(rawTransaction, opts)
-                            .catch((e) => {
-                            console.error(e);
-                            stopWaiting();
-                        });
-                        this.sendToAdditionalConnections(rawTransaction, opts);
-                    }
-                }
-            }))();
-            let slot;
-            try {
-                const result = yield this.confirmTransaction(txid, opts.commitment);
-                slot = result.context.slot;
-            }
-            catch (e) {
-                console.error(e);
-                throw e;
-            }
-            finally {
-                stopWaiting();
-            }
-            return { txSig: txid, slot };
-        });
-    }
-    prepareTx(tx, additionalSigners, opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            tx.feePayer = this.provider.wallet.publicKey;
-            tx.recentBlockhash = (yield this.provider.connection.getRecentBlockhash(opts.preflightCommitment)).blockhash;
-            yield this.provider.wallet.signTransaction(tx);
-            additionalSigners
-                .filter((s) => s !== undefined)
-                .forEach((kp) => {
-                tx.partialSign(kp);
-            });
-            return tx;
-        });
-    }
-    confirmTransaction(signature, commitment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let decodedSignature;
-            try {
-                decodedSignature = bs58_1.default.decode(signature);
-            }
-            catch (err) {
-                throw new Error('signature must be base58 encoded: ' + signature);
-            }
-            assert_1.default(decodedSignature.length === 64, 'signature has invalid length');
-            const start = Date.now();
-            const subscriptionCommitment = commitment || this.provider.opts.commitment;
-            const subscriptionIds = new Array();
-            const connections = [
-                this.provider.connection,
-                ...this.additionalConnections,
-            ];
-            let response = null;
-            const promises = connections.map((connection, i) => {
-                let subscriptionId;
-                const confirmPromise = new Promise((resolve, reject) => {
-                    try {
-                        subscriptionId = connection.onSignature(signature, (result, context) => {
-                            subscriptionIds[i] = undefined;
-                            response = {
-                                context,
-                                value: result,
-                            };
-                            resolve(null);
-                        }, subscriptionCommitment);
-                    }
-                    catch (err) {
-                        reject(err);
-                    }
-                });
-                subscriptionIds.push(subscriptionId);
-                return confirmPromise;
-            });
-            try {
-                yield this.promiseTimeout(promises, this.timeout);
-            }
-            finally {
-                for (const [i, subscriptionId] of subscriptionIds.entries()) {
-                    if (subscriptionId) {
-                        connections[i].removeSignatureListener(subscriptionId);
-                    }
-                }
-            }
-            if (response === null) {
-                const duration = (Date.now() - start) / 1000;
-                throw new Error(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`);
-            }
-            return response;
-        });
-    }
-    getTimestamp() {
-        return new Date().getTime();
-    }
-    sleep(reference) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve) => {
-                reference.resolve = resolve;
-                setTimeout(resolve, this.retrySleep);
-            });
-        });
-    }
-    promiseTimeout(promises, timeoutMs) {
-        let timeoutId;
-        const timeoutPromise = new Promise((resolve) => {
-            timeoutId = setTimeout(() => resolve(null), timeoutMs);
-        });
-        return Promise.race([...promises, timeoutPromise]).then((result) => {
-            clearTimeout(timeoutId);
-            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);
-            });
-        });
-    }
-    addAdditionalConnection(newConnection) {
-        const alreadyUsingConnection = this.additionalConnections.filter((connection) => {
-            // @ts-ignore
-            return connection._rpcEndpoint === newConnection.rpcEndpoint;
-        }).length > 0;
-        if (!alreadyUsingConnection) {
-            this.additionalConnections.push(newConnection);
-        }
-    }
-}
-exports.RetryTxSender = RetryTxSender;