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

package/src/tx/retryTxSender.js

@@ -0,0 +1,188 @@
+"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;

package/src/tx/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/tx/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapInTx = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const COMPUTE_UNITS_DEFAULT = 200000;
+function wrapInTx(instruction, computeUnits = 600000 // TODO, requires less code change
+) {
+    const tx = new web3_js_1.Transaction();
+    if (computeUnits != COMPUTE_UNITS_DEFAULT) {
+        tx.add(web3_js_1.ComputeBudgetProgram.requestUnits({
+            units: computeUnits,
+            additionalFee: 0,
+        }));
+    }
+    return tx.add(instruction);
+}
+exports.wrapInTx = wrapInTx;

package/src/tx/utils.ts

@@ -8,7 +8,7 @@ const COMPUTE_UNITS_DEFAULT = 200_000;
 
 export function wrapInTx(
 	instruction: TransactionInstruction,
-	computeUnits = 500_000 // TODO, requires less code change
+	computeUnits = 600_000 // TODO, requires less code change
 ): Transaction {
 	const tx = new Transaction();
 	if (computeUnits != COMPUTE_UNITS_DEFAULT) {

package/src/types.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultOrderParams = exports.TradeSide = exports.isOneOfVariant = exports.isVariant = exports.OrderTriggerCondition = exports.OrderActionExplanation = exports.OrderAction = exports.OrderDiscountTier = exports.OrderStatus = exports.OrderType = exports.OracleSource = exports.DepositDirection = exports.PositionDirection = exports.BankBalanceType = exports.SwapDirection = void 0;
+const _1 = require(".");
+// # Utility Types / Enums / Constants
+class SwapDirection {
+}
+exports.SwapDirection = SwapDirection;
+SwapDirection.ADD = { add: {} };
+SwapDirection.REMOVE = { remove: {} };
+class BankBalanceType {
+}
+exports.BankBalanceType = BankBalanceType;
+BankBalanceType.DEPOSIT = { deposit: {} };
+BankBalanceType.BORROW = { borrow: {} };
+class PositionDirection {
+}
+exports.PositionDirection = PositionDirection;
+PositionDirection.LONG = { long: {} };
+PositionDirection.SHORT = { short: {} };
+class DepositDirection {
+}
+exports.DepositDirection = DepositDirection;
+DepositDirection.DEPOSIT = { deposit: {} };
+DepositDirection.WITHDRAW = { withdraw: {} };
+class OracleSource {
+}
+exports.OracleSource = OracleSource;
+OracleSource.PYTH = { pyth: {} };
+OracleSource.SWITCHBOARD = { switchboard: {} };
+OracleSource.QUOTE_ASSET = { quoteAsset: {} };
+class OrderType {
+}
+exports.OrderType = OrderType;
+OrderType.LIMIT = { limit: {} };
+OrderType.TRIGGER_MARKET = { triggerMarket: {} };
+OrderType.TRIGGER_LIMIT = { triggerLimit: {} };
+OrderType.MARKET = { market: {} };
+class OrderStatus {
+}
+exports.OrderStatus = OrderStatus;
+OrderStatus.INIT = { init: {} };
+OrderStatus.OPEN = { open: {} };
+class OrderDiscountTier {
+}
+exports.OrderDiscountTier = OrderDiscountTier;
+OrderDiscountTier.NONE = { none: {} };
+OrderDiscountTier.FIRST = { first: {} };
+OrderDiscountTier.SECOND = { second: {} };
+OrderDiscountTier.THIRD = { third: {} };
+OrderDiscountTier.FOURTH = { fourth: {} };
+class OrderAction {
+}
+exports.OrderAction = OrderAction;
+OrderAction.PLACE = { place: {} };
+OrderAction.CANCEL = { cancel: {} };
+OrderAction.EXPIRE = { expire: {} };
+OrderAction.FILL = { fill: {} };
+OrderAction.TRIGGER = { trigger: {} };
+class OrderActionExplanation {
+}
+exports.OrderActionExplanation = OrderActionExplanation;
+OrderActionExplanation.NONE = { none: {} };
+OrderActionExplanation.BREACHED_MARGIN_REQUIREMENT = {
+    breachedMarginRequirement: {},
+};
+OrderActionExplanation.ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
+    oraclePriceBreachedLimitPrice: {},
+};
+OrderActionExplanation.MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
+    marketOrderFilledToLimitPrice: {},
+};
+class OrderTriggerCondition {
+}
+exports.OrderTriggerCondition = OrderTriggerCondition;
+OrderTriggerCondition.ABOVE = { above: {} };
+OrderTriggerCondition.BELOW = { below: {} };
+function isVariant(object, type) {
+    return object.hasOwnProperty(type);
+}
+exports.isVariant = isVariant;
+function isOneOfVariant(object, types) {
+    return types.reduce((result, type) => {
+        return result || object.hasOwnProperty(type);
+    }, false);
+}
+exports.isOneOfVariant = isOneOfVariant;
+var TradeSide;
+(function (TradeSide) {
+    TradeSide[TradeSide["None"] = 0] = "None";
+    TradeSide[TradeSide["Buy"] = 1] = "Buy";
+    TradeSide[TradeSide["Sell"] = 2] = "Sell";
+})(TradeSide = exports.TradeSide || (exports.TradeSide = {}));
+exports.DefaultOrderParams = {
+    orderType: OrderType.MARKET,
+    userOrderId: 0,
+    direction: PositionDirection.LONG,
+    baseAssetAmount: _1.ZERO,
+    price: _1.ZERO,
+    marketIndex: _1.ZERO,
+    reduceOnly: false,
+    postOnly: false,
+    immediateOrCancel: false,
+    triggerPrice: _1.ZERO,
+    triggerCondition: OrderTriggerCondition.ABOVE,
+    positionLimit: _1.ZERO,
+    oraclePriceOffset: _1.ZERO,
+    padding0: _1.ZERO,
+    padding1: _1.ZERO,
+    optionalAccounts: {
+        discountToken: false,
+        referrer: false,
+    },
+};

package/src/types.ts

@@ -1,5 +1,5 @@
 import { PublicKey, Transaction } from '@solana/web3.js';
-import { BN } from '.';
+import { BN, ZERO } from '.';
 
 // # Utility Types / Enums / Constants
 export class SwapDirection {
@@ -17,6 +17,11 @@ export class PositionDirection {
 	static readonly SHORT = { short: {} };
 }
 
+export class DepositDirection {
+	static readonly DEPOSIT = { deposit: {} };
+	static readonly WITHDRAW = { withdraw: {} };
+}
+
 export class OracleSource {
 	static readonly PYTH = { pyth: {} };
 	static readonly SWITCHBOARD = { switchboard: {} };
@@ -48,6 +53,20 @@ export class OrderAction {
 	static readonly CANCEL = { cancel: {} };
 	static readonly EXPIRE = { expire: {} };
 	static readonly FILL = { fill: {} };
+	static readonly TRIGGER = { trigger: {} };
+}
+
+export class OrderActionExplanation {
+	static readonly NONE = { none: {} };
+	static readonly BREACHED_MARGIN_REQUIREMENT = {
+		breachedMarginRequirement: {},
+	};
+	static readonly ORACLE_PRICE_BREACHED_LIMIT_PRICE = {
+		oraclePriceBreachedLimitPrice: {},
+	};
+	static readonly MARKET_ORDER_FILLED_TO_LIMIT_PRICE = {
+		marketOrderFilledToLimitPrice: {},
+	};
 }
 
 export class OrderTriggerCondition {
@@ -91,6 +110,7 @@ export type DepositRecord = {
 	};
 	bankIndex: BN;
 	amount: BN;
+	oraclePrice: BN;
 	from?: PublicKey;
 	to?: PublicKey;
 };
@@ -141,20 +161,67 @@ export type FundingPaymentRecord = {
 
 export type LiquidationRecord = {
 	ts: BN;
-	recordId: BN;
-	userAuthority: PublicKey;
 	user: PublicKey;
-	partial: boolean;
-	baseAssetValue: BN;
-	baseAssetValueClosed: BN;
-	liquidationFee: BN;
-	feeToLiquidator: BN;
-	feeToInsuranceFund: BN;
 	liquidator: PublicKey;
+	liquidationType: LiquidationType;
+	marginRequirement: BN;
 	totalCollateral: BN;
-	collateral: BN;
-	unrealizedPnl: BN;
-	marginRatio: BN;
+	liquidatePerp: LiquidatePerpRecord;
+	liquidateBorrow: LiquidateBorrowRecord;
+	liquidateBorrowForPerpPnl: LiquidateBorrowForPerpPnlRecord;
+	liquidatePerpPnlForDeposit: LiquidatePerpPnlForDepositRecord;
+};
+
+export class LiquidationType {
+	static readonly LIQUIDATE_PERP = { liquidatePerp: {} };
+	static readonly LIQUIDATE_BORROW = { liquidateBorrow: {} };
+	static readonly LIQUIDATE_BORROW_FOR_PERP_PNL = {
+		liquidateBorrowForPerpPnl: {},
+	};
+	static readonly LIQUIDATE_PERP_PNL_FOR_DEPOSIT = {
+		liquidatePerpPnlForDeposit: {},
+	};
+}
+
+export type LiquidatePerpRecord = {
+	marketIndex: BN;
+	orderIds: BN[];
+	oraclePrice: BN;
+	baseAssetAmount: BN;
+	quoteAssetAmount: BN;
+	userPnl: BN;
+	liquidatorPnl: BN;
+	canceledOrdersFee: BN;
+	userOrderId: BN;
+	liquidatorOrderId: BN;
+	fillRecordId: BN;
+};
+
+export type LiquidateBorrowRecord = {
+	assetBankIndex: BN;
+	assetPrice: BN;
+	assetTransfer: BN;
+	liabilityBankIndex: BN;
+	liabilityPrice: BN;
+	liabilityTransfer: BN;
+};
+
+export type LiquidateBorrowForPerpPnlRecord = {
+	marketIndex: BN;
+	marketOraclePrice: BN;
+	pnlTransfer: BN;
+	liabilityBankIndex: BN;
+	liabilityPrice: BN;
+	liabilityTransfer: BN;
+};
+
+export type LiquidatePerpPnlForDepositRecord = {
+	marketIndex: BN;
+	marketOraclePrice: BN;
+	pnlTransfer: BN;
+	assetBankIndex: BN;
+	assetPrice: BN;
+	assetTransfer: BN;
 };
 
 export type OrderRecord = {
@@ -163,7 +230,10 @@ export type OrderRecord = {
 	maker: PublicKey;
 	takerOrder: Order;
 	makerOrder: Order;
+	takerUnsettledPnl: BN;
+	makerUnsettledPnl: BN;
 	action: OrderAction;
+	actionExplanation: OrderActionExplanation;
 	filler: PublicKey;
 	fillRecordId: BN;
 	marketIndex: BN;
@@ -218,9 +288,9 @@ export type MarketAccount = {
 	openInterest: BN;
 	marginRatioInitial: number;
 	marginRatioMaintenance: number;
-	marginRatioPartial: number;
 	nextFillRecordId: BN;
 	pnlPool: PoolBalance;
+	liquidationFee: BN;
 };
 
 export type BankAccount = {
@@ -244,6 +314,7 @@ export type BankAccount = {
 	maintenanceAssetWeight: BN;
 	initialLiabilityWeight: BN;
 	maintenanceLiabilityWeight: BN;
+	liquidationFee: BN;
 };
 
 export type PoolBalance = {
@@ -260,6 +331,8 @@ export type AMM = {
 	lastMarkPriceTwapTs: BN;
 	lastOraclePriceTwap: BN;
 	lastOraclePriceTwapTs: BN;
+	lastOracleMarkSpreadPct: BN;
+	lastOracleConfPct: BN;
 	oracle: PublicKey;
 	oracleSource: OracleSource;
 	fundingPeriod: BN;
@@ -274,6 +347,8 @@ export type AMM = {
 	totalFee: BN;
 	minimumQuoteAssetTradeSize: BN;
 	baseAssetAmountStepSize: BN;
+	maxBaseAssetAmountRatio: number;
+	maxSlippageRatio: number;
 	lastOraclePrice: BN;
 	baseSpread: number;
 	curveUpdateIntensity: number;
@@ -290,6 +365,7 @@ export type AMM = {
 	lastAskPriceTwap: BN;
 	longSpread: BN;
 	shortSpread: BN;
+	maxSpread: number;
 };
 
 // # User Account Types
@@ -321,6 +397,7 @@ export type UserAccount = {
 	};
 	positions: UserPosition[];
 	orders: Order[];
+	beingLiquidated: boolean;
 };
 
 export type UserBankBalance = {
@@ -347,8 +424,9 @@ export type Order = {
 	reduceOnly: boolean;
 	triggerPrice: BN;
 	triggerCondition: OrderTriggerCondition;
+	triggered: boolean;
 	discountTier: OrderDiscountTier;
-	existingPositionDirection: PositionDirection,
+	existingPositionDirection: PositionDirection;
 	referrer: PublicKey;
 	postOnly: boolean;
 	immediateOrCancel: boolean;
@@ -362,7 +440,6 @@ export type OrderParams = {
 	orderType: OrderType;
 	userOrderId: number;
 	direction: PositionDirection;
-	quoteAssetAmount: BN;
 	baseAssetAmount: BN;
 	price: BN;
 	marketIndex: BN;
@@ -381,11 +458,49 @@ export type OrderParams = {
 	};
 };
 
+export type NecessaryOrderParams = {
+	orderType: OrderType;
+	marketIndex: BN;
+	baseAssetAmount: BN;
+	direction: PositionDirection;
+};
+
+export type OptionalOrderParams = {
+	[Property in keyof OrderParams]?: OrderParams[Property];
+} & NecessaryOrderParams;
+
+export const DefaultOrderParams = {
+	orderType: OrderType.MARKET,
+	userOrderId: 0,
+	direction: PositionDirection.LONG,
+	baseAssetAmount: ZERO,
+	price: ZERO,
+	marketIndex: ZERO,
+	reduceOnly: false,
+	postOnly: false,
+	immediateOrCancel: false,
+	triggerPrice: ZERO,
+	triggerCondition: OrderTriggerCondition.ABOVE,
+	positionLimit: ZERO,
+	oraclePriceOffset: ZERO,
+	padding0: ZERO,
+	padding1: ZERO,
+	optionalAccounts: {
+		discountToken: false,
+		referrer: false,
+	},
+};
+
 export type MakerInfo = {
 	maker: PublicKey;
 	order: Order;
 };
 
+export type TakerInfo = {
+	taker: PublicKey;
+	order: Order;
+};
+
 // # Misc Types
 export interface IWallet {
 	signTransaction(tx: Transaction): Promise<Transaction>;
@@ -427,6 +542,7 @@ export type FeeStructure = {
 	makerRebateNumerator: BN;
 	makerRebateDenominator: BN;
 	fillerRewardStructure: OrderFillerRewardStructure;
+	cancelOrderFee: BN;
 };
 
 export type OracleGuardRails = {
@@ -448,4 +564,4 @@ export type OrderFillerRewardStructure = {
 	timeBasedRewardLowerBound: BN;
 };
 
-export type MarginCategory = 'Initial' | 'Partial' | 'Maintenance';
+export type MarginCategory = 'Initial' | 'Maintenance';

package/src/userName.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeName = exports.encodeName = exports.DEFAULT_USER_NAME = exports.MAX_NAME_LENGTH = void 0;
+exports.MAX_NAME_LENGTH = 32;
+exports.DEFAULT_USER_NAME = 'Main Account';
+function encodeName(name) {
+    if (name.length > exports.MAX_NAME_LENGTH) {
+        throw Error(`User name (${name}) longer than 32 characters`);
+    }
+    const buffer = Buffer.alloc(32);
+    buffer.fill(name);
+    buffer.fill(' ', name.length);
+    return Array(...buffer);
+}
+exports.encodeName = encodeName;
+function decodeName(bytes) {
+    const buffer = Buffer.from(bytes);
+    return buffer.toString('utf8').trim();
+}
+exports.decodeName = decodeName;

package/src/util/computeUnits.ts

@@ -9,7 +9,7 @@ export async function findComputeUnitConsumption(
 	const tx = await connection.getTransaction(txSignature, { commitment });
 	const computeUnits = [];
 	const regex = new RegExp(
-		`Program ${programId.toString()} consumed ([0-9]{0,6}) of 200000 compute units`
+		`Program ${programId.toString()} consumed ([0-9]{0,6}) of ([0-9]{0,7}) compute units`
 	);
 	tx.meta.logMessages.forEach((logMessage) => {
 		const match = logMessage.match(regex);

package/src/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/src/util/tps.js

@@ -0,0 +1,27 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTps = void 0;
+function estimateTps(programId, connection, failed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let signatures = yield connection.getSignaturesForAddress(programId, undefined, 'finalized');
+        if (failed) {
+            signatures = signatures.filter((signature) => signature.err);
+        }
+        const numberOfSignatures = signatures.length;
+        if (numberOfSignatures === 0) {
+            return 0;
+        }
+        return (numberOfSignatures /
+            (signatures[0].blockTime - signatures[numberOfSignatures - 1].blockTime));
+    });
+}
+exports.estimateTps = estimateTps;