@pyron-finance/pyron-client 2.5.2 → 2.6.0

package/dist/common/index.js

@@ -1,3 +1,1160 @@
-import { $t as median, A as getMeanPrioritizationFeeByPercentile, B as getComputeBudgetUnits, C as aprToApy, D as PriotitizationFeeLevels, E as calculateInterestFromApy, F as compareInstructions, G as replaceV0TxBlockhash, Gt as chunkedGetRawMultipleAccountInfoOrderedWithNulls, H as isV0Tx, Ht as TransactionConfigMap, I as decodeComputeBudgetInstruction, J as uiToMicroLamports, Jt as getValueInsensitive, K as replaceV0TxInstructions, Kt as chunkedGetRawMultipleAccountInfos, L as decodeInstruction, M as getMinPrioritizationFeeByPercentile, N as getRecentPrioritizationFeesByPercentile, O as getCalculatedPrioritizationFeeByPercentile, P as addTransactionMetadata, Qt as floor, R as decompileV0Transaction, S as wrappedI80F48toBigNumber, T as calculateApyFromInterest, U as legacyTxToV0Tx, Ut as TransactionType, V as getTxSize, Vt as TransactionArenaKeyMap, W as microLamportsToUi, Wt as chunkedGetRawMultipleAccountInfoOrdered, Xt as sleep, Y as updateV0Tx, Yt as setTimeoutPromise, Zt as ceil, _ as shortenAddress, a as groupedNumberFormatterDyn, b as uiToNative, c as percentFormatterDyn, d as usdFormatter, en as NodeWallet, f as usdFormatterDyn, g as nativeToUi, h as composeRemainingAccounts, i as groupedNumberFormatter, j as getMedianPrioritizationFeeByPercentile, k as getMaxPrioritizationFeeByPercentile, l as percentFormatterMod, m as bpsToPercentile, n as clampedNumeralFormatter, nn as fetchBanksExtendedMetadata, o as numeralFormatter, p as bigNumberToWrappedI80F48, q as splitInstructionsToFitTransactions, qt as chunks, r as dynamicNumeralFormatter, rn as parseBanksMetadataOverride, s as percentFormatter, t as CustomNumberFormat, tn as bankExtendedMetadataOverrideSchema, u as tokenPriceFormatter, v as toBigNumber, w as apyToApr, x as uiToNativeBigNumber, y as toNumber, z as getAccountKeys } from "../common-IgVl6MYx.js";
+// src/common/nodeWallet.ts
+var NodeWallet = class {
+  /**
+   * @param payer Keypair of the associated payer
+   */
+  constructor(payer) {
+    this.payer = payer;
+  }
+  async signTransaction(tx) {
+    if ("version" in tx) {
+      tx.sign([this.payer]);
+    } else {
+      tx.partialSign(this.payer);
+    }
+    return tx;
+  }
+  async signAllTransactions(txs) {
+    return txs.map((tx) => {
+      if ("version" in tx) {
+        tx.sign([this.payer]);
+        return tx;
+      } else {
+        tx.partialSign(this.payer);
+        return tx;
+      }
+    });
+  }
+  get publicKey() {
+    return this.payer.publicKey;
+  }
+};
 
-export { CustomNumberFormat, NodeWallet, PriotitizationFeeLevels, TransactionArenaKeyMap, TransactionConfigMap, TransactionType, addTransactionMetadata, aprToApy, apyToApr, bankExtendedMetadataOverrideSchema, bigNumberToWrappedI80F48, bpsToPercentile, calculateApyFromInterest, calculateInterestFromApy, ceil, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, chunks, clampedNumeralFormatter, compareInstructions, composeRemainingAccounts, decodeComputeBudgetInstruction, decodeInstruction, decompileV0Transaction, dynamicNumeralFormatter, fetchBanksExtendedMetadata, floor, getAccountKeys, getCalculatedPrioritizationFeeByPercentile, getComputeBudgetUnits, getMaxPrioritizationFeeByPercentile, getMeanPrioritizationFeeByPercentile, getMedianPrioritizationFeeByPercentile, getMinPrioritizationFeeByPercentile, getRecentPrioritizationFeesByPercentile, getTxSize, getValueInsensitive, groupedNumberFormatter, groupedNumberFormatterDyn, isV0Tx, legacyTxToV0Tx, median, microLamportsToUi, nativeToUi, numeralFormatter, parseBanksMetadataOverride, percentFormatter, percentFormatterDyn, percentFormatterMod, replaceV0TxBlockhash, replaceV0TxInstructions, setTimeoutPromise, shortenAddress, sleep, splitInstructionsToFitTransactions, toBigNumber, toNumber, tokenPriceFormatter, uiToMicroLamports, uiToNative, uiToNativeBigNumber, updateV0Tx, usdFormatter, usdFormatterDyn, wrappedI80F48toBigNumber };
+// src/common/math.ts
+function floor(value, decimals) {
+  return Math.floor(value * 10 ** decimals) / 10 ** decimals;
+}
+function ceil(value, decimals) {
+  return Math.ceil(value * 10 ** decimals) / 10 ** decimals;
+}
+function median(values) {
+  if (values.length === 0) {
+    throw new Error("Input array is empty");
+  }
+  const sortedValues = [...values].sort((a, b) => a - b);
+  const half = Math.floor(sortedValues.length / 2);
+  return sortedValues.length % 2 ? sortedValues[half] : (sortedValues[half - 1] + sortedValues[half]) / 2;
+}
+
+// src/common/misc.ts
+import { PublicKey } from "@solana/web3.js";
+function getValueInsensitive(map, key) {
+  const lowerCaseLabel = key.toLowerCase();
+  for (const key2 in map) {
+    if (key2.toLowerCase() === lowerCaseLabel) {
+      return map[key2];
+    }
+  }
+  throw new Error(`Token metadata not found for ${key}`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function chunks(array, size) {
+  return Array.apply(0, new Array(Math.ceil(array.length / size))).map(
+    (_, index) => array.slice(index * size, (index + 1) * size)
+  );
+}
+function setTimeoutPromise(duration, message) {
+  return new Promise((_, reject) => setTimeout(() => reject(new Error(message)), duration));
+}
+async function chunkedGetRawMultipleAccountInfos(connection, pks, batchChunkSize = 1e3, maxAccountsChunkSize = 100) {
+  const accountInfoMap = /* @__PURE__ */ new Map();
+  let contextSlot = 0;
+  const batches = chunkArray(pks, batchChunkSize);
+  for (let i = 0; i < batches.length; i++) {
+    const batch = batches[i];
+    const batchRequest = chunkArray(batch, maxAccountsChunkSize).map((pubkeys) => ({
+      methodName: "getMultipleAccounts",
+      args: connection._buildArgs([pubkeys], "confirmed", "base64")
+    }));
+    let accountInfos = [];
+    let retries = 0;
+    const maxRetries = 3;
+    while (retries < maxRetries && accountInfos.length === 0) {
+      try {
+        accountInfos = await connection._rpcBatchRequest(batchRequest).then((batchResults) => {
+          contextSlot = Math.max(...batchResults.map((res) => res.result.context.slot));
+          const accounts = batchResults.reduce(
+            (acc, res) => {
+              acc.push(...res.result.value);
+              return acc;
+            },
+            []
+          );
+          return accounts;
+        });
+      } catch (_error) {
+        retries++;
+      }
+    }
+    if (accountInfos.length === 0) {
+      throw new Error(`Failed to fetch account infos after ${maxRetries} retries`);
+    }
+    accountInfos.forEach((item, index) => {
+      const publicKey = batch[index];
+      if (item) {
+        accountInfoMap.set(publicKey, {
+          ...item,
+          owner: new PublicKey(item.owner),
+          data: Buffer.from(item.data[0], "base64")
+        });
+      }
+    });
+  }
+  return [contextSlot, accountInfoMap];
+}
+async function chunkedGetRawMultipleAccountInfoOrderedWithNulls(connection, pks, batchChunkSize = 1e3, maxAccountsChunkSize = 100) {
+  const allAccountInfos = [];
+  const batches = chunkArray(pks, batchChunkSize);
+  for (let i = 0; i < batches.length; i++) {
+    const batch = batches[i];
+    const batchRequest = chunkArray(batch, maxAccountsChunkSize).map((pubkeys) => ({
+      methodName: "getMultipleAccounts",
+      args: connection._buildArgs([pubkeys], "confirmed", "base64")
+    }));
+    let accountInfos = [];
+    let retries = 0;
+    const maxRetries = 3;
+    while (retries < maxRetries && accountInfos.length === 0) {
+      try {
+        accountInfos = await connection._rpcBatchRequest(batchRequest).then((batchResults) => {
+          const accounts = batchResults.reduce(
+            (acc, res) => {
+              acc.push(...res.result.value);
+              return acc;
+            },
+            []
+          );
+          return accounts;
+        });
+      } catch (_error) {
+        retries++;
+      }
+    }
+    if (accountInfos.length === 0) {
+      throw new Error(`Failed to fetch account infos after ${maxRetries} retries`);
+    }
+    accountInfos.forEach((item) => {
+      if (item) {
+        allAccountInfos.push({
+          ...item,
+          owner: new PublicKey(item.owner),
+          data: Buffer.from(item.data[0], "base64")
+        });
+      } else {
+        allAccountInfos.push(null);
+      }
+    });
+  }
+  return allAccountInfos;
+}
+async function chunkedGetRawMultipleAccountInfoOrdered(connection, pks, batchChunkSize = 1e3, maxAccountsChunkSize = 100) {
+  const allAccountInfos = [];
+  const batches = chunkArray(pks, batchChunkSize);
+  for (let i = 0; i < batches.length; i++) {
+    const batch = batches[i];
+    const batchRequest = chunkArray(batch, maxAccountsChunkSize).map((pubkeys) => ({
+      methodName: "getMultipleAccounts",
+      args: connection._buildArgs([pubkeys], "confirmed", "base64")
+    }));
+    let accountInfos = [];
+    let retries = 0;
+    const maxRetries = 3;
+    while (retries < maxRetries && accountInfos.length === 0) {
+      try {
+        accountInfos = await connection._rpcBatchRequest(batchRequest).then((batchResults) => {
+          const accounts = batchResults.reduce(
+            (acc, res) => {
+              acc.push(...res.result.value);
+              return acc;
+            },
+            []
+          );
+          return accounts;
+        });
+      } catch (_error) {
+        retries++;
+      }
+    }
+    if (accountInfos.length === 0) {
+      throw new Error(`Failed to fetch account infos after ${maxRetries} retries`);
+    }
+    accountInfos.forEach((item) => {
+      if (item) {
+        allAccountInfos.push({
+          ...item,
+          owner: new PublicKey(item.owner),
+          data: Buffer.from(item.data[0], "base64")
+        });
+      }
+    });
+  }
+  return allAccountInfos;
+}
+function chunkArray(array, chunkSize) {
+  const chunks2 = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    chunks2.push(array.slice(i, i + chunkSize));
+  }
+  return chunks2;
+}
+
+// src/common/modules/transactions/transaction.types.ts
+import {
+  PublicKey as PublicKey2
+} from "@solana/web3.js";
+var TransactionType = /* @__PURE__ */ ((TransactionType2) => {
+  TransactionType2["DEPOSIT"] = "DEPOSIT";
+  TransactionType2["WITHDRAW"] = "WITHDRAW";
+  TransactionType2["REPAY"] = "REPAY";
+  TransactionType2["BORROW"] = "BORROW";
+  TransactionType2["FLASHLOAN"] = "FLASHLOAN";
+  TransactionType2["LOOP"] = "LOOP";
+  TransactionType2["REPAY_COLLAT"] = "REPAY_COLLAT";
+  TransactionType2["LONG"] = "LONG";
+  TransactionType2["SHORT"] = "SHORT";
+  TransactionType2["CREATE_ACCOUNT"] = "CREATE_ACCOUNT";
+  TransactionType2["CREATE_ATA"] = "CREATE_ATA";
+  TransactionType2["CLOSE_ACCOUNT"] = "CLOSE_ACCOUNT";
+  TransactionType2["CLOSE_POSITION"] = "CLOSE_POSITION";
+  TransactionType2["MOVE_POSITION_WITHDRAW"] = "MOVE_POSITION_WITHDRAW";
+  TransactionType2["MOVE_POSITION_DEPOSIT"] = "MOVE_POSITION_DEPOSIT";
+  TransactionType2["WITHDRAW_ALL"] = "WITHDRAW_ALL";
+  TransactionType2["TRANSFER_AUTH"] = "TRANSFER_AUTH";
+  TransactionType2["CRANK"] = "CRANK";
+  TransactionType2["DEPOSIT_STAKE"] = "DEPOSIT_STAKE";
+  TransactionType2["WITHDRAW_STAKE"] = "WITHDRAW_STAKE";
+  TransactionType2["INITIALIZE_STAKED_POOL"] = "INITIALIZE_STAKED_POOL";
+  TransactionType2["ADD_STAKED_BANK"] = "ADD_STAKED_BANK";
+  TransactionType2["MERGE_STAKE_ACCOUNTS"] = "MERGE_STAKE_ACCOUNTS";
+  TransactionType2["STAKE_TO_STAKE"] = "STAKE_TO_STAKE";
+  TransactionType2["MINT_LST_NATIVE"] = "MINT_LST_NATIVE";
+  TransactionType2["SWAP_TO_SOL"] = "SWAP_TO_SOL";
+  TransactionType2["SOL_TO_LST"] = "SOL_TO_LST";
+  TransactionType2["UNSTAKE_LST"] = "UNSTAKE_LST";
+  TransactionType2["WITHDRAW_EMISSIONS"] = "WITHDRAW_EMISSIONS";
+  TransactionType2["LIQUIDATE_ACCOUNT"] = "LIQUIDATE_ACCOUNT";
+  TransactionType2["CREATE_PERM_BANK"] = "CREATE_PERM_BANK";
+  TransactionType2["CREATE_GROUP"] = "CREATE_GROUP";
+  TransactionType2["JUPITER_SWAP"] = "JUPITER_SWAP";
+  return TransactionType2;
+})(TransactionType || {});
+var TransactionConfigMap = {
+  // BASE LENDING ACTIONS
+  ["DEPOSIT" /* DEPOSIT */]: {
+    label: ({ amount, token } = {}) => amount && token ? `Deposit ${amount} ${token}` : "Deposit"
+  },
+  ["WITHDRAW" /* WITHDRAW */]: {
+    label: ({ amount, token } = {}) => amount && token ? `Withdraw ${amount} ${token}` : "Withdraw"
+  },
+  ["REPAY" /* REPAY */]: {
+    label: ({ amount, token } = {}) => amount && token ? `Repay ${amount} ${token}` : "Repay"
+  },
+  ["BORROW" /* BORROW */]: {
+    label: ({ amount, token } = {}) => amount && token ? `Borrow ${amount} ${token}` : "Borrow"
+  },
+  // FLASHLOANS
+  ["FLASHLOAN" /* FLASHLOAN */]: { label: () => "Executing Flashloan" },
+  ["LOOP" /* LOOP */]: {
+    label: ({ depositAmount, depositToken, borrowAmount, borrowToken } = {}) => depositAmount && depositToken && borrowAmount && borrowToken ? `Loop ${depositAmount} ${depositToken} with ${borrowAmount} ${borrowToken}` : "Loop"
+  },
+  ["REPAY_COLLAT" /* REPAY_COLLAT */]: {
+    label: ({ repayAmount, repayToken, amount, token } = {}) => repayAmount && repayToken && amount && token ? `Repay ${repayAmount} ${token} with   ${amount} ${repayToken}` : "Repay with collateral"
+  },
+  ["LONG" /* LONG */]: {
+    label: ({ depositToken, depositAmount, borrowToken } = {}) => depositToken && depositAmount && borrowToken ? `Long ${depositToken} with ${depositAmount} ${borrowToken}` : "Open long position"
+  },
+  ["SHORT" /* SHORT */]: {
+    label: ({ borrowToken, depositAmount, depositToken } = {}) => borrowToken && depositAmount && depositToken ? `Short ${borrowToken} with ${depositAmount} ${depositToken}` : "Open short position"
+  },
+  // SWB
+  ["CRANK" /* CRANK */]: { label: () => "Updating latest prices" },
+  ["JUPITER_SWAP" /* JUPITER_SWAP */]: {
+    label: ({ originAmount, originToken, destinationAmount, destinationToken } = {}) => originAmount && originToken && destinationAmount && destinationToken ? `Swap ${originAmount} ${originToken} for ${destinationAmount} ${destinationToken}` : "Swap tokens"
+  },
+  // SETUP
+  ["CREATE_ACCOUNT" /* CREATE_ACCOUNT */]: { label: () => "Create lendr account" },
+  ["CREATE_ATA" /* CREATE_ATA */]: { label: () => "Configure token account" },
+  // ACCOUNT MANAGEMENT
+  ["CLOSE_ACCOUNT" /* CLOSE_ACCOUNT */]: { label: () => "Close lendr account" },
+  ["CLOSE_POSITION" /* CLOSE_POSITION */]: { label: () => "Close position" },
+  ["MOVE_POSITION_WITHDRAW" /* MOVE_POSITION_WITHDRAW */]: {
+    label: ({ originAccountAddress } = {}) => `Move position from ${originAccountAddress}`
+  },
+  ["MOVE_POSITION_DEPOSIT" /* MOVE_POSITION_DEPOSIT */]: {
+    label: ({ destinationAccountAddress } = {}) => `Move position to ${destinationAccountAddress}`
+  },
+  ["TRANSFER_AUTH" /* TRANSFER_AUTH */]: { label: () => "Authorize account transfer" },
+  // NATIVE STAKE ACTIONS
+  ["DEPOSIT_STAKE" /* DEPOSIT_STAKE */]: {
+    label: ({ amount, token } = {}) => amount && token ? `Authorize stake account and deposit ${amount} ${token}` : "Authorize stake and deposit"
+  },
+  ["WITHDRAW_STAKE" /* WITHDRAW_STAKE */]: {
+    label: () => "Authorize stake account"
+  },
+  ["INITIALIZE_STAKED_POOL" /* INITIALIZE_STAKED_POOL */]: { label: () => "Initialize stake pool" },
+  ["ADD_STAKED_BANK" /* ADD_STAKED_BANK */]: { label: () => "Create staked asset bank" },
+  ["MERGE_STAKE_ACCOUNTS" /* MERGE_STAKE_ACCOUNTS */]: { label: () => "Merge stake accounts" },
+  // LST (Liquid Staking Tokens)
+  ["STAKE_TO_STAKE" /* STAKE_TO_STAKE */]: { label: () => "Convert stake" },
+  ["MINT_LST_NATIVE" /* MINT_LST_NATIVE */]: { label: () => "Mint LST" },
+  ["SWAP_TO_SOL" /* SWAP_TO_SOL */]: {
+    label: ({ swapAmount, token } = {}) => swapAmount && token ? `Swap ${swapAmount} ${token} to SOL` : "Swap to SOL"
+  },
+  ["SOL_TO_LST" /* SOL_TO_LST */]: {
+    label: ({ amount } = {}) => amount ? `Mint LST with ${amount} SOL` : "Mint LST with SOL"
+  },
+  ["UNSTAKE_LST" /* UNSTAKE_LST */]: { label: ({ amount } = {}) => amount ? `Unstake ${amount} LST` : "Unstake LST" },
+  // EMISSIONS
+  ["WITHDRAW_EMISSIONS" /* WITHDRAW_EMISSIONS */]: { label: () => "Withdraw emissions" },
+  // LIQUIDATE
+  ["LIQUIDATE_ACCOUNT" /* LIQUIDATE_ACCOUNT */]: { label: () => "Liquidate account" },
+  // BANK and GROUPS
+  ["CREATE_PERM_BANK" /* CREATE_PERM_BANK */]: { label: () => "Create permissionless bank" },
+  ["CREATE_GROUP" /* CREATE_GROUP */]: { label: () => "Create lendr group" },
+  ["WITHDRAW_ALL" /* WITHDRAW_ALL */]: {
+    label: ({ amount, token } = {}) => amount && token ? `Withdraw ${amount} ${token}` : "Withdraw all"
+  }
+};
+var TransactionArenaKeyMap = {
+  ["DEPOSIT" /* DEPOSIT */]: new PublicKey2("ArenaDeposit1111111111111111111111111111111"),
+  ["WITHDRAW" /* WITHDRAW */]: new PublicKey2("ArenaWithdraw111111111111111111111111111111"),
+  ["BORROW" /* BORROW */]: new PublicKey2("ArenaBorrow11111111111111111111111111111111"),
+  ["REPAY" /* REPAY */]: new PublicKey2("ArenaRepay111111111111111111111111111111111"),
+  ["REPAY_COLLAT" /* REPAY_COLLAT */]: new PublicKey2("ArenaRepayCo11at111111111111111111111111111"),
+  ["LONG" /* LONG */]: new PublicKey2("ArenaLong1111111111111111111111111111111111"),
+  ["SHORT" /* SHORT */]: new PublicKey2("ArenaShort111111111111111111111111111111111"),
+  ["CLOSE_POSITION" /* CLOSE_POSITION */]: new PublicKey2("ArenaC1ose111111111111111111111111111111111")
+  // Add more mappings if needed
+};
+
+// src/common/modules/transactions/transaction.utils.ts
+import { BorshInstructionCoder } from "@coral-xyz/anchor";
+import {
+  ComputeBudgetProgram,
+  LAMPORTS_PER_SOL,
+  TransactionMessage,
+  VersionedTransaction
+} from "@solana/web3.js";
+
+// src/constants/bank.ts
+var PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED = Buffer.from("liquidity_vault_auth");
+var PDA_BANK_INSURANCE_VAULT_AUTH_SEED = Buffer.from("insurance_vault_auth");
+var PDA_BANK_FEE_VAULT_AUTH_SEED = Buffer.from("fee_vault_auth");
+var PDA_BANK_LIQUIDITY_VAULT_SEED = Buffer.from("liquidity_vault");
+var PDA_BANK_INSURANCE_VAULT_SEED = Buffer.from("insurance_vault");
+var PDA_BANK_FEE_VAULT_SEED = Buffer.from("fee_vault");
+
+// src/constants/defaults.ts
+var DEFAULT_COMMITMENT = "processed";
+var DEFAULT_SEND_OPTS = {
+  skipPreflight: false,
+  preflightCommitment: DEFAULT_COMMITMENT
+};
+var DEFAULT_CONFIRM_OPTS = {
+  commitment: DEFAULT_COMMITMENT,
+  ...DEFAULT_SEND_OPTS
+};
+var MAX_TX_SIZE = 1232;
+
+// src/constants/flags.ts
+var DISABLED_FLAG = 1 << 0;
+var FLASHLOAN_ENABLED_FLAG = 1 << 2;
+var TRANSFER_ACCOUNT_AUTHORITY_FLAG = 1 << 3;
+
+// src/constants/misc.ts
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
+import BigNumber from "bignumber.js";
+var HOURS_PER_YEAR = 365.25 * 24;
+var MAX_U64 = BigInt("18446744073709551615").toString();
+var PYTH_PRICE_CONF_INTERVALS = new BigNumber(2.12);
+var SWB_PRICE_CONF_INTERVALS = new BigNumber(1.96);
+var MAX_CONFIDENCE_INTERVAL_RATIO = new BigNumber(0.05);
+var PYTH_PUSH_ORACLE_ID = new PublicKey3("pythWSnswVUd12oZpeFP8e9CVaEqJg25g1Vtc2biRsT");
+var GROUP_PK = new PublicKey3(process.env.LENDR_GROUP_PK ?? "4vDRNkXaeAcwJULZCQFFdNBM295sD8hSKQt3RaMwsRFc");
+var PROGRAM_ID = new PublicKey3(process.env.LENDR_PROGRAM_ID ?? "89ZQeCPwkzSPJyTpktCKWNY6hBWMKuYt47R85Jo36yyh");
+var DEFAULT_CLUSTER = process.env.LENDR_CLUSTER_OVERRIDE ?? "mainnet";
+
+// src/constants/programs.ts
+import { PublicKey as PublicKey4 } from "@solana/web3.js";
+var JUPITER_V6_PROGRAM = new PublicKey4("JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4");
+var LENDR_PROGRAM = new PublicKey4("89ZQeCPwkzSPJyTpktCKWNY6hBWMKuYt47R85Jo36yyh");
+var SINGLE_POOL_PROGRAM_ID = new PublicKey4("SVSPxpvHdN29nkVg9rPapPNDddN5DipNLRUFhyjFThE");
+var STAKE_PROGRAM_ID = new PublicKey4("Stake11111111111111111111111111111111111111");
+var MPL_METADATA_PROGRAM_ID = new PublicKey4("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+var SYSTEM_PROGRAM_ID = new PublicKey4("11111111111111111111111111111111");
+var SYSVAR_RENT_ID = new PublicKey4("SysvarRent111111111111111111111111111111111");
+var SYSVAR_CLOCK_ID = new PublicKey4("SysvarC1ock11111111111111111111111111111111");
+var SYSVAR_STAKE_HISTORY_ID = new PublicKey4("SysvarStakeHistory1111111111111111111111111");
+var STAKE_CONFIG_ID = new PublicKey4("StakeConfig11111111111111111111111111111111");
+
+// src/constants/tokens.ts
+import { PublicKey as PublicKey5 } from "@solana/web3.js";
+var WSOL_MINT = new PublicKey5("So11111111111111111111111111111111111111112");
+var WSOL_EXTENDED_METADATA = {
+  symbol: "wSOL",
+  name: "Wrapped SOL",
+  address: "D7zkaUgFUDkhQHExySRxokL3Fa1GFnnuiVDTs9yMrFHY",
+  logoURI: "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/So11111111111111111111111111111111111111112/logo.png",
+  additionalMetadata: [],
+  uri: "",
+  mint: WSOL_MINT.toBase58()
+};
+var LST_MINT = new PublicKey5("LSTxxxnJzKDFSLr4dUkPcmCf5VyryEqzPLz5j4bpxFp");
+var USDC_MINT = new PublicKey5("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+var DUMMY_USDC_MINT = new PublicKey5("JAiSLhTCvAhGM4SojCYGoTPuqjw7KaCsopvRuNryzbML");
+
+// src/common/modules/transactions/transaction.utils.ts
+function isV0Tx(tx) {
+  return "message" in tx;
+}
+function getTxSize(tx) {
+  const isVersioned = isV0Tx(tx);
+  const numSigners = tx.signatures.length;
+  const numRequiredSignatures = isVersioned ? tx.message.header.numRequiredSignatures : 0;
+  const feePayerSize = isVersioned || tx.feePayer ? 0 : 32;
+  const signaturesSize = (numRequiredSignatures - numSigners) * 64 + 1;
+  try {
+    const baseTxSize = isVersioned ? tx.serialize().length : tx.serialize({ requireAllSignatures: false, verifySignatures: false }).length;
+    return baseTxSize + feePayerSize + signaturesSize;
+  } catch (_error) {
+    return 9999;
+  }
+}
+function getAccountKeys(tx, lookupTableAccounts) {
+  const isVersioned = isV0Tx(tx);
+  try {
+    if (isVersioned) {
+      const message = TransactionMessage.decompile(tx.message, { addressLookupTableAccounts: lookupTableAccounts });
+      return message.compileToLegacyMessage().getAccountKeys().length;
+    } else {
+      return tx.compileMessage().getAccountKeys().length;
+    }
+  } catch (_error) {
+    return 9999;
+  }
+}
+function decodeInstruction(idl, encoded) {
+  const coder = new BorshInstructionCoder(idl);
+  return coder.decode(encoded, "base58");
+}
+function decompileV0Transaction(tx, lookupTableAccounts) {
+  return TransactionMessage.decompile(tx.message, { addressLookupTableAccounts: lookupTableAccounts });
+}
+function legacyTxToV0Tx(transaction, opts) {
+  const feePayer = opts?.feePayer ?? transaction.feePayer;
+  const blockhash = opts?.blockhash ?? transaction.recentBlockhash;
+  const additionalIxs = opts?.additionalIxs ?? [];
+  const addressLookupTables = opts?.addressLookupTables ?? [];
+  if (!feePayer || !blockhash) {
+    throw new Error("Fee payer and blockhash are required");
+  }
+  const ixs = transaction.instructions;
+  const versionedMessage = new TransactionMessage({
+    instructions: [...additionalIxs, ...ixs],
+    payerKey: feePayer,
+    recentBlockhash: blockhash
+  });
+  return new VersionedTransaction(versionedMessage.compileToV0Message(addressLookupTables));
+}
+function updateV0Tx(transaction, opts) {
+  const additionalIxs = opts?.additionalIxs ?? [];
+  const addressLookupTables = opts?.addressLookupTables ?? [];
+  let instructions = [];
+  const message = decompileV0Transaction(transaction, addressLookupTables);
+  const feePayer = opts?.feePayer ?? message.payerKey;
+  const blockhash = opts?.blockhash ?? message.recentBlockhash;
+  if (additionalIxs.length > 0) {
+    instructions = replaceV0TxInstructions(additionalIxs, message.instructions, opts?.replaceOnly);
+  } else {
+    instructions = message.instructions;
+  }
+  const versionedMessage = new TransactionMessage({
+    instructions,
+    payerKey: feePayer,
+    recentBlockhash: blockhash
+  });
+  return new VersionedTransaction(versionedMessage.compileToV0Message(addressLookupTables));
+}
+function compareInstructions(ix1, ix2) {
+  const dataCompare = ix1.data.equals(ix2.data);
+  const programIdCompare = ix1.programId.equals(ix2.programId);
+  const keysCompare = ix1.keys.length === ix2.keys.length && ix1.keys.every((key, index) => {
+    const key2 = ix2.keys[index];
+    return key.pubkey.equals(key2.pubkey) && key.isSigner === key2.isSigner && key.isWritable === key2.isWritable;
+  });
+  return dataCompare && programIdCompare && keysCompare;
+}
+function replaceV0TxInstructions(additionalInstructions, instructions, replaceOnly) {
+  let updatedAdditionalIxs = additionalInstructions;
+  const updatedInstructions = instructions.map((ix) => {
+    const programId = ix.programId;
+    const additionalIxs = additionalInstructions.filter((a) => a.programId.equals(programId));
+    if (additionalIxs.length > 0) {
+      if (ix.programId.equals(ComputeBudgetProgram.programId)) {
+        const decoded = decodeComputeBudgetInstruction(ix);
+        const updatedCuPriceIx = additionalIxs.find(
+          (a) => decodeComputeBudgetInstruction(a).instructionType === "SetComputeUnitPrice"
+        );
+        const updatedCuLimitIx = additionalIxs.find(
+          (a) => decodeComputeBudgetInstruction(a).instructionType === "SetComputeUnitLimit"
+        );
+        if (decoded.instructionType === "SetComputeUnitPrice" && updatedCuPriceIx) {
+          updatedAdditionalIxs = updatedAdditionalIxs.filter((a) => !compareInstructions(a, updatedCuPriceIx));
+          return updatedCuPriceIx;
+        }
+        if (decoded.instructionType === "SetComputeUnitLimit" && updatedCuLimitIx) {
+          updatedAdditionalIxs = updatedAdditionalIxs.filter((a) => !compareInstructions(a, updatedCuLimitIx));
+          return updatedCuLimitIx;
+        }
+      }
+    }
+    return ix;
+  });
+  return [...replaceOnly ? [] : updatedAdditionalIxs, ...updatedInstructions];
+}
+function replaceV0TxBlockhash(transaction, blockhash) {
+  const message = transaction.message;
+  message.recentBlockhash = blockhash;
+  return new VersionedTransaction(message);
+}
+function addTransactionMetadata(transaction, options) {
+  return Object.assign(transaction, options);
+}
+function identifyComputeBudgetInstruction(data) {
+  const discriminator = data.readUInt8(0);
+  switch (discriminator) {
+    case 0:
+      return "RequestUnits";
+    case 1:
+      return "RequestHeapFrame";
+    case 2:
+      return "SetComputeUnitLimit";
+    case 3:
+      return "SetComputeUnitPrice";
+    case 4:
+      return "SetLoadedAccountsDataSizeLimit";
+    default:
+      throw new Error("Unknown ComputeBudget instruction discriminator.");
+  }
+}
+function decodeComputeBudgetInstruction(instruction) {
+  const data = Buffer.from(instruction.data || instruction);
+  const instructionType = identifyComputeBudgetInstruction(data);
+  switch (instructionType) {
+    case "RequestUnits": {
+      if (data.length !== 9) {
+        throw new Error("Invalid data length for RequestUnits");
+      }
+      const units = data.readUInt32LE(1);
+      const additionalFee = data.readUInt32LE(5);
+      return { instructionType, units, additionalFee };
+    }
+    case "RequestHeapFrame": {
+      if (data.length !== 5) {
+        throw new Error("Invalid data length for RequestHeapFrame");
+      }
+      const bytes = data.readUInt32LE(1);
+      return { instructionType, bytes };
+    }
+    case "SetComputeUnitLimit": {
+      if (data.length !== 5) {
+        throw new Error("Invalid data length for SetComputeUnitLimit");
+      }
+      const units = data.readUInt32LE(1);
+      return { instructionType, units };
+    }
+    case "SetComputeUnitPrice": {
+      if (data.length !== 9) {
+        throw new Error("Invalid data length for SetComputeUnitPrice");
+      }
+      const microLamports = data.readBigUInt64LE(1);
+      return { instructionType, microLamports: microLamports.toString() };
+    }
+    case "SetLoadedAccountsDataSizeLimit": {
+      if (data.length !== 5) {
+        throw new Error("Invalid data length for SetLoadedAccountsDataSizeLimit");
+      }
+      const accountDataSizeLimit = data.readUInt32LE(1);
+      return { instructionType, accountDataSizeLimit };
+    }
+    default:
+      throw new Error("Unknown ComputeBudget instruction type.");
+  }
+}
+var DEFAULT_COMPUTE_BUDGET_IX = 2e5;
+function getComputeBudgetUnits(tx) {
+  let instructions = [];
+  if (isV0Tx(tx)) {
+    const addressLookupTableAccounts = tx.addressLookupTables ?? [];
+    const message = decompileV0Transaction(tx, addressLookupTableAccounts);
+    instructions = message.instructions;
+  } else {
+    instructions = tx.instructions;
+  }
+  const computeBudgetIxs = instructions.filter((ix) => ix.programId.equals(ComputeBudgetProgram.programId));
+  if (computeBudgetIxs.length === 0) {
+    return Math.min(instructions.length * DEFAULT_COMPUTE_BUDGET_IX, 14e5);
+  }
+  const decoded = computeBudgetIxs.map((ix) => decodeComputeBudgetInstruction(ix));
+  const limit = decoded.find((ix) => ix.instructionType === "SetComputeUnitLimit");
+  return limit?.units ?? instructions.length * DEFAULT_COMPUTE_BUDGET_IX;
+}
+var uiToMicroLamports = (ui, limitCU = 14e5) => {
+  const priorityFeeMicroLamports = ui * LAMPORTS_PER_SOL * 1e6;
+  return priorityFeeMicroLamports / limitCU;
+};
+var microLamportsToUi = (microLamports, limitCU = 14e5) => {
+  const priorityFeeMicroLamports = microLamports * limitCU;
+  const priorityFeeUi = priorityFeeMicroLamports / (LAMPORTS_PER_SOL * 1e6);
+  return Math.trunc(priorityFeeUi * LAMPORTS_PER_SOL) / LAMPORTS_PER_SOL;
+};
+function splitInstructionsToFitTransactions(mandatoryIxs, ixs, opts) {
+  const result = [];
+  let buffer = [];
+  function buildTx(mandatoryIxs2, extraIxs, opts2) {
+    const messageV0 = new TransactionMessage({
+      payerKey: opts2.payerKey,
+      recentBlockhash: opts2.blockhash,
+      instructions: [...mandatoryIxs2, ...extraIxs]
+    }).compileToV0Message(opts2.luts);
+    return new VersionedTransaction(messageV0);
+  }
+  for (const ix of ixs) {
+    const trial = buildTx(mandatoryIxs, [...buffer, ix], opts);
+    if (getTxSize(trial) <= MAX_TX_SIZE) {
+      buffer.push(ix);
+    } else {
+      if (buffer.length === 0) {
+        throw new Error("Single instruction too large to fit in a transaction");
+      }
+      const tx = buildTx(mandatoryIxs, buffer, opts);
+      result.push(tx);
+      buffer = [ix];
+      const solo = buildTx(mandatoryIxs, buffer, opts);
+      if (getTxSize(solo) > MAX_TX_SIZE) {
+        throw new Error("Single instruction too large to fit in a transaction");
+      }
+    }
+  }
+  if (buffer.length > 0) {
+    const tx = buildTx(mandatoryIxs, buffer, opts);
+    result.push(tx);
+  }
+  return result;
+}
+
+// src/common/priority.ts
+var PriotitizationFeeLevels = /* @__PURE__ */ ((PriotitizationFeeLevels2) => {
+  PriotitizationFeeLevels2[PriotitizationFeeLevels2["LOW"] = 2500] = "LOW";
+  PriotitizationFeeLevels2[PriotitizationFeeLevels2["MEDIAN"] = 5e3] = "MEDIAN";
+  PriotitizationFeeLevels2[PriotitizationFeeLevels2["HIGH"] = 7500] = "HIGH";
+  PriotitizationFeeLevels2[PriotitizationFeeLevels2["MAX"] = 1e4] = "MAX";
+  return PriotitizationFeeLevels2;
+})(PriotitizationFeeLevels || {});
+var getCalculatedPrioritizationFeeByPercentile = async (connection, config, slotsToReturn) => {
+  const fees = await getRecentPrioritizationFeesByPercentile(connection, config, slotsToReturn);
+  const { min, max, sum } = fees.reduce(
+    (acc, fee) => ({
+      min: fee.prioritizationFee < acc.min.prioritizationFee ? fee : acc.min,
+      max: fee.prioritizationFee > acc.max.prioritizationFee ? fee : acc.max,
+      sum: acc.sum + fee.prioritizationFee
+    }),
+    { min: fees[0], max: fees[0], sum: 0 }
+  );
+  const mean = Math.ceil(sum / fees.length);
+  const sortedFees = [...fees].sort((a, b) => a.prioritizationFee - b.prioritizationFee);
+  const midIndex = Math.floor(fees.length / 2);
+  const median2 = fees.length % 2 === 0 ? Math.ceil((sortedFees[midIndex - 1].prioritizationFee + sortedFees[midIndex].prioritizationFee) / 2) : sortedFees[midIndex].prioritizationFee;
+  return {
+    min,
+    max,
+    mean,
+    median: median2
+  };
+};
+var getMinPrioritizationFeeByPercentile = async (connection, config, slotsToReturn) => {
+  const recentPrioritizationFees = await getRecentPrioritizationFeesByPercentile(connection, config, slotsToReturn);
+  const minPriorityFee = recentPrioritizationFees.reduce((min, current) => {
+    return current.prioritizationFee < min.prioritizationFee ? current : min;
+  });
+  return minPriorityFee.prioritizationFee;
+};
+var getMaxPrioritizationFeeByPercentile = async (connection, config, slotsToReturn) => {
+  const recentPrioritizationFees = await getRecentPrioritizationFeesByPercentile(connection, config, slotsToReturn);
+  const maxPriorityFee = recentPrioritizationFees.reduce((max, current) => {
+    return current.prioritizationFee > max.prioritizationFee ? current : max;
+  });
+  return maxPriorityFee.prioritizationFee;
+};
+var getMeanPrioritizationFeeByPercentile = async (connection, config, slotsToReturn) => {
+  const recentPrioritizationFees = await getRecentPrioritizationFeesByPercentile(connection, config, slotsToReturn);
+  const mean = Math.ceil(
+    recentPrioritizationFees.reduce((acc, fee) => acc + fee.prioritizationFee, 0) / recentPrioritizationFees.length
+  );
+  return mean;
+};
+var getMedianPrioritizationFeeByPercentile = async (connection, config, slotsToReturn) => {
+  const recentPrioritizationFees = await getRecentPrioritizationFeesByPercentile(connection, config, slotsToReturn);
+  recentPrioritizationFees.sort((a, b) => a.prioritizationFee - b.prioritizationFee);
+  const half = Math.floor(recentPrioritizationFees.length / 2);
+  if (recentPrioritizationFees.length % 2) {
+    return recentPrioritizationFees[half].prioritizationFee;
+  }
+  return Math.ceil(
+    (recentPrioritizationFees[half - 1].prioritizationFee + recentPrioritizationFees[half].prioritizationFee) / 2
+  );
+};
+var getRecentPrioritizationFeesFromRpc = async (config, rpcRequest) => {
+  const accounts = config?.lockedWritableAccounts?.map((key) => key.toBase58());
+  const args = accounts?.length ? [accounts] : [[]];
+  config.percentile && args.push({ percentile: config.percentile });
+  const response = await rpcRequest("getRecentPrioritizationFees", args);
+  return response;
+};
+var getRecentPrioritizationFeesByPercentile = async (connection, config, slotsToReturn) => {
+  const { fallback = true, lockedWritableAccounts = [] } = config || {};
+  const validSlotsToReturn = slotsToReturn && Number.isInteger(slotsToReturn) ? slotsToReturn : -1;
+  const promises = [];
+  let tritonRpcResponse;
+  let fallbackRpcResponse;
+  const rpcRequest = connection._rpcRequest;
+  promises.push(
+    getRecentPrioritizationFeesFromRpc(config, rpcRequest).then((result) => {
+      tritonRpcResponse = result;
+    })
+  );
+  if (fallback) {
+    promises.push(
+      getRecentPrioritizationFeesFromRpc({ lockedWritableAccounts }, rpcRequest).then((result) => {
+        fallbackRpcResponse = result;
+      })
+    );
+  }
+  await Promise.all(promises);
+  const tritonGRPFResponse = tritonRpcResponse;
+  const fallbackGRPFResponse = fallbackRpcResponse;
+  let recentPrioritizationFees = [];
+  if (tritonGRPFResponse?.result) {
+    recentPrioritizationFees = tritonGRPFResponse.result;
+  }
+  if (fallbackGRPFResponse?.result && !tritonGRPFResponse?.result) {
+    recentPrioritizationFees = fallbackGRPFResponse.result;
+  }
+  if (fallback && fallbackGRPFResponse.error) {
+    return fallbackGRPFResponse.error;
+  }
+  if (tritonGRPFResponse?.error) {
+    return tritonGRPFResponse.error;
+  }
+  recentPrioritizationFees.sort((a, b) => a.slot - b.slot);
+  if (validSlotsToReturn > 0) return recentPrioritizationFees.slice(0, validSlotsToReturn);
+  return recentPrioritizationFees;
+};
+
+// src/common/utils/accounting.utils.ts
+var apyToApr = (apy, compoundingFrequency = HOURS_PER_YEAR) => ((1 + apy) ** (1 / compoundingFrequency) - 1) * compoundingFrequency;
+var aprToApy = (apr, compoundingFrequency = HOURS_PER_YEAR, apyCap = 3) => Math.min((1 + apr / compoundingFrequency) ** compoundingFrequency - 1, apyCap);
+function calculateInterestFromApy(principal, durationInYears, apy) {
+  return principal * apy * durationInYears;
+}
+function calculateApyFromInterest(principal, durationInYears, interest) {
+  return interest / (principal * durationInYears);
+}
+
+// src/common/utils/conversion.utils.ts
+import BigNumber2 from "bignumber.js";
+import BN from "bn.js";
+import { Decimal } from "decimal.js";
+var I80F48_FRACTIONAL_BYTES = 6;
+var I80F48_TOTAL_BYTES = 16;
+var I80F48_DIVISOR = new Decimal(2).pow(8 * I80F48_FRACTIONAL_BYTES);
+function wrappedI80F48toBigNumber(wrapped) {
+  const bytesLE = wrapped.value;
+  if (bytesLE.length !== I80F48_TOTAL_BYTES) {
+    throw new Error(`Expected a ${I80F48_TOTAL_BYTES}-byte buffer`);
+  }
+  let bytesBE = bytesLE.slice();
+  bytesBE.reverse();
+  let signChar = "";
+  const msb = bytesBE[0];
+  if (msb & 128) {
+    signChar = "-";
+    bytesBE = bytesBE.map((v) => ~v & 255);
+  }
+  const hex = `${signChar}0x${bytesBE.map((v) => v.toString(16).padStart(2, "0")).join("")}`;
+  const decoded = new Decimal(hex).dividedBy(I80F48_DIVISOR);
+  return new BigNumber2(decoded.toString());
+}
+function bigNumberToWrappedI80F48(value) {
+  let decimalValue = new Decimal(value.toString());
+  const isNegative = decimalValue.isNegative();
+  decimalValue = decimalValue.times(I80F48_DIVISOR);
+  let wrappedValue = new BN(decimalValue.round().toFixed()).toArray();
+  if (wrappedValue.length < I80F48_TOTAL_BYTES) {
+    const padding = Array(I80F48_TOTAL_BYTES - wrappedValue.length).fill(0);
+    wrappedValue.unshift(...padding);
+  }
+  if (isNegative) {
+    wrappedValue[wrappedValue.length - 1] |= 128;
+    wrappedValue = wrappedValue.map((v) => ~v & 255);
+  }
+  wrappedValue.reverse();
+  return { value: wrappedValue };
+}
+function toNumber(amount) {
+  let amt;
+  if (typeof amount === "number") {
+    amt = amount;
+  } else if (typeof amount === "string") {
+    amt = Number(amount);
+  } else {
+    amt = amount.toNumber();
+  }
+  return amt;
+}
+function toBigNumber(amount) {
+  let amt;
+  if (amount instanceof BigNumber2) {
+    amt = amount;
+  } else {
+    amt = new BigNumber2(amount.toString());
+  }
+  return amt;
+}
+function uiToNative(amount, decimals) {
+  const amt = toBigNumber(amount);
+  return new BN(amt.times(10 ** decimals).toFixed(0, BigNumber2.ROUND_FLOOR));
+}
+function uiToNativeBigNumber(amount, decimals) {
+  const amt = toBigNumber(amount);
+  return amt.times(10 ** decimals);
+}
+function nativeToUi(amount, decimals) {
+  const amt = toBigNumber(amount);
+  return amt.div(10 ** decimals).toNumber();
+}
+function shortenAddress(pubkey, chars = 4) {
+  const pubkeyStr = pubkey.toString();
+  return `${pubkeyStr.slice(0, chars)}...${pubkeyStr.slice(-chars)}`;
+}
+function bpsToPercentile(bps) {
+  return bps / 1e4;
+}
+var composeRemainingAccounts = (banksAndOracles) => {
+  banksAndOracles.sort((a, b) => {
+    const A = a[0].toBytes();
+    const B = b[0].toBytes();
+    for (let i = 0; i < 32; i++) {
+      if (A[i] !== B[i]) {
+        return B[i] - A[i];
+      }
+    }
+    return 0;
+  });
+  return banksAndOracles.flat();
+};
+
+// src/common/utils/formatters.utils.ts
+import numeral from "numeral";
+var CustomNumberFormat = class extends Intl.NumberFormat {
+  format(value) {
+    if (value === 0) {
+      return "-";
+    } else {
+      return super.format(value);
+    }
+  }
+};
+var groupedNumberFormatter = new CustomNumberFormat("en-US", {
+  useGrouping: true,
+  minimumFractionDigits: 0,
+  maximumFractionDigits: 2
+});
+var numeralFormatter = (value) => {
+  if (value < 0.01) {
+    return "0";
+  } else {
+    return numeral(value).format("0.00a");
+  }
+};
+var dynamicNumeralFormatter = (value, options = {}) => {
+  const {
+    minDisplay = 1e-5,
+    // Default minDisplay for backward compatibility
+    maxDisplay = 1e4,
+    // Default maxDisplay for backward compatibility
+    tokenPrice,
+    logging = false,
+    ignoreMinDisplay = false,
+    // New flag to control ignoring minDisplay
+    forceDecimals
+  } = options;
+  if (value === 0 || Number.isNaN(value)) return "0";
+  const absValue = Math.abs(value);
+  if (logging) {
+    console.log({
+      value,
+      minDisplay,
+      maxDisplay,
+      tokenPrice,
+      ignoreMinDisplay,
+      absValue
+    });
+  }
+  if (!ignoreMinDisplay && absValue < minDisplay) {
+    return `<${minDisplay}`;
+  }
+  if (absValue > maxDisplay) {
+    return numeral(value).format(forceDecimals ? "0,0.00a" : "0,0.[00]a");
+  }
+  if (!ignoreMinDisplay && Math.abs(value) >= 0.01) {
+    return numeral(value).format(forceDecimals && Math.abs(value) > 0.99 ? "0,0.00a" : "0,0.[0000]a");
+  }
+  if (ignoreMinDisplay) {
+    const decimalPart = absValue - Math.floor(absValue);
+    const decimalPlaces = decimalPart > 0 ? 3 : 0;
+    if (absValue >= 1) {
+      return value.toFixed(decimalPlaces).replace(/\.?0+$/, "");
+    } else {
+      const exponent = Math.floor(Math.log10(absValue));
+      const significantDecimals = Math.max(3, 2 - exponent);
+      return value.toFixed(significantDecimals).replace(/\.?0+$/, "");
+    }
+  }
+  if (Math.abs(value) >= minDisplay) {
+    const decimalPlaces = Math.max(0, Math.ceil(-Math.log10(minDisplay)));
+    return numeral(value).format(`0,0.[${"0".repeat(decimalPlaces)}]`);
+  }
+  if (tokenPrice) {
+    const smallestUnit = minDisplay / tokenPrice;
+    const significantDecimals = Math.max(3, Math.ceil(-Math.log10(smallestUnit)));
+    return value.toFixed(significantDecimals).replace(/\.?0+$/, "");
+  }
+  return "0";
+};
+var groupedNumberFormatterDyn = new Intl.NumberFormat("en-US", {
+  useGrouping: true,
+  minimumFractionDigits: 0,
+  maximumFractionDigits: 2
+});
+var usdFormatter = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2,
+  signDisplay: "auto"
+});
+var usdFormatterDyn = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  minimumFractionDigits: 0,
+  maximumFractionDigits: 2,
+  signDisplay: "auto"
+});
+var percentFormatter = new Intl.NumberFormat("en-US", {
+  style: "percent",
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2
+});
+var percentFormatterDyn = new Intl.NumberFormat("en-US", {
+  style: "percent",
+  minimumFractionDigits: 0,
+  maximumFractionDigits: 2
+});
+var percentFormatterMod = (value, opts = { minFractionDigits: 2, maxFractionDigits: 2 }) => {
+  const percentFormatter2 = new Intl.NumberFormat("en-US", {
+    style: "percent",
+    minimumFractionDigits: opts.minFractionDigits,
+    maximumFractionDigits: opts.maxFractionDigits
+  });
+  if (value === 0) {
+    return "0%";
+  } else {
+    return percentFormatter2.format(value);
+  }
+};
+var clampedNumeralFormatter = (value) => {
+  if (value === 0) {
+    return "0";
+  } else if (value < 0.01) {
+    return "< 0.01";
+  } else {
+    return numeral(value).format("0.00a");
+  }
+};
+var tokenPriceFormatter = (price, style = "currency") => {
+  if (price === 0) {
+    return 0;
+  }
+  const reformatNum = Number(price.toFixed(20));
+  if (price === 0) {
+    return 0;
+  }
+  if (reformatNum < 1e-8) {
+    return price.toExponential(2);
+  }
+  const { minFractionDigits, maxFractionDigits } = reformatNum > 1 ? { minFractionDigits: 2, maxFractionDigits: 2 } : reformatNum > 1e-6 ? { minFractionDigits: 2, maxFractionDigits: 7 } : { minFractionDigits: 7, maxFractionDigits: 10 };
+  const formatter = new Intl.NumberFormat("en-US", {
+    style,
+    currency: "USD",
+    minimumFractionDigits: minFractionDigits,
+    maximumFractionDigits: maxFractionDigits,
+    signDisplay: "auto"
+  });
+  return formatter.format(price);
+};
+
+// src/common/bank-metadata.ts
+import { z } from "zod";
+var bankExtendedMetadataOverrideSchema = z.object({
+  name: z.string().optional(),
+  symbol: z.string().optional(),
+  logoURI: z.string().url().optional(),
+  // TODO)) [later] remove these if not used anywhere
+  address: z.string().optional(),
+  mint: z.string().optional(),
+  // TODO)) added in new IDL version
+  validatorVoteAccount: z.string().optional()
+});
+var parseBanksMetadataOverride = (data) => {
+  return z.record(z.string(), bankExtendedMetadataOverrideSchema).parse(data);
+};
+var fetchBanksExtendedMetadata = async ({
+  mintsWithOwner,
+  metadataService,
+  logger,
+  overrideBanksMetadata
+}) => {
+  const metas = await metadataService.forMints(mintsWithOwner.map(({ mint }) => mint));
+  const results = await Promise.all(
+    mintsWithOwner.map(async ({ mint }) => {
+      const mintAddress = mint.toBase58();
+      const tokenMeta = metas[mintAddress];
+      if (!tokenMeta) {
+        logger.warn({ mintStr: mintAddress }, "fetched metadata was null");
+        if (!overrideBanksMetadata) {
+          return null;
+        }
+        const overrideMetadata2 = Object.values(overrideBanksMetadata).find((m) => m?.mint === mintAddress);
+        if (!overrideMetadata2) {
+          return null;
+        }
+        const { name: name2, symbol: symbol2, logoURI } = overrideMetadata2;
+        if (name2 && symbol2) {
+          return {
+            mint: mintAddress,
+            name: name2,
+            symbol: symbol2,
+            logoURI,
+            uri: "",
+            additionalMetadata: []
+          };
+        }
+        logger.warn(
+          {
+            overrideMetadata: overrideMetadata2,
+            mint: mintAddress
+          },
+          "override metadata exists but is missing required fields: name, symbol, mint"
+        );
+        return null;
+      }
+      const { name, symbol, image, uri } = tokenMeta;
+      const overrideMetadata = overrideBanksMetadata?.[symbol];
+      return {
+        mint: mintAddress,
+        name: overrideMetadata?.name ?? name,
+        symbol: overrideMetadata?.symbol ?? symbol,
+        logoURI: overrideMetadata?.logoURI ?? image,
+        uri: uri ?? "",
+        additionalMetadata: []
+      };
+    })
+  );
+  const metadataMap = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    if (!result) continue;
+    metadataMap.set(result.mint, result);
+  }
+  return metadataMap;
+};
+export {
+  CustomNumberFormat,
+  NodeWallet,
+  PriotitizationFeeLevels,
+  TransactionArenaKeyMap,
+  TransactionConfigMap,
+  TransactionType,
+  addTransactionMetadata,
+  aprToApy,
+  apyToApr,
+  bankExtendedMetadataOverrideSchema,
+  bigNumberToWrappedI80F48,
+  bpsToPercentile,
+  calculateApyFromInterest,
+  calculateInterestFromApy,
+  ceil,
+  chunkedGetRawMultipleAccountInfoOrdered,
+  chunkedGetRawMultipleAccountInfoOrderedWithNulls,
+  chunkedGetRawMultipleAccountInfos,
+  chunks,
+  clampedNumeralFormatter,
+  compareInstructions,
+  composeRemainingAccounts,
+  decodeComputeBudgetInstruction,
+  decodeInstruction,
+  decompileV0Transaction,
+  dynamicNumeralFormatter,
+  fetchBanksExtendedMetadata,
+  floor,
+  getAccountKeys,
+  getCalculatedPrioritizationFeeByPercentile,
+  getComputeBudgetUnits,
+  getMaxPrioritizationFeeByPercentile,
+  getMeanPrioritizationFeeByPercentile,
+  getMedianPrioritizationFeeByPercentile,
+  getMinPrioritizationFeeByPercentile,
+  getRecentPrioritizationFeesByPercentile,
+  getTxSize,
+  getValueInsensitive,
+  groupedNumberFormatter,
+  groupedNumberFormatterDyn,
+  isV0Tx,
+  legacyTxToV0Tx,
+  median,
+  microLamportsToUi,
+  nativeToUi,
+  numeralFormatter,
+  parseBanksMetadataOverride,
+  percentFormatter,
+  percentFormatterDyn,
+  percentFormatterMod,
+  replaceV0TxBlockhash,
+  replaceV0TxInstructions,
+  setTimeoutPromise,
+  shortenAddress,
+  sleep,
+  splitInstructionsToFitTransactions,
+  toBigNumber,
+  toNumber,
+  tokenPriceFormatter,
+  uiToMicroLamports,
+  uiToNative,
+  uiToNativeBigNumber,
+  updateV0Tx,
+  usdFormatter,
+  usdFormatterDyn,
+  wrappedI80F48toBigNumber
+};