@0dotxyz/p0-ts-sdk 2.8.2 → 2.8.3-alpha.0

package/dist/index.cjs

@@ -74918,6 +74918,231 @@ async function computeSmartCrank({
     isCrankable: true
   });
 }
+new web3_js.PublicKey("MarBmsSgKXdrN1egZf5sqe1TMai9K1rChYNDJgjq7aD");
+var MARINADE_STATE_DISCRIMINATOR = Buffer.from([216, 146, 107, 94, 104, 75, 182, 177]);
+var DELAYED_UNSTAKE_COOLING_DOWN_OFFSET = 226;
+var TOTAL_ACTIVE_BALANCE_OFFSET = 376;
+var AVAILABLE_RESERVE_BALANCE_OFFSET = 496;
+var MSOL_SUPPLY_OFFSET = 504;
+var CIRCULATING_TICKET_BALANCE_OFFSET = 528;
+var EMERGENCY_COOLING_DOWN_OFFSET = 568;
+var MARINADE_STATE_MIN_SIZE = EMERGENCY_COOLING_DOWN_OFFSET + 8;
+var U64_MAX = (1n << 64n) - 1n;
+var MAX_MSOL_SOL_RATE = 3;
+function decodeMarinadeState(data) {
+  if (data.length < MARINADE_STATE_MIN_SIZE) {
+    throw new Error(`Invalid Marinade State account size: ${data.length}`);
+  }
+  if (!data.subarray(0, 8).equals(MARINADE_STATE_DISCRIMINATOR)) {
+    throw new Error("Invalid Marinade State discriminator");
+  }
+  const delayedUnstakeCoolingDown = data.readBigUInt64LE(DELAYED_UNSTAKE_COOLING_DOWN_OFFSET);
+  const totalActiveBalance = data.readBigUInt64LE(TOTAL_ACTIVE_BALANCE_OFFSET);
+  const availableReserveBalance = data.readBigUInt64LE(AVAILABLE_RESERVE_BALANCE_OFFSET);
+  const msolSupply = data.readBigUInt64LE(MSOL_SUPPLY_OFFSET);
+  const circulatingTicketBalance = data.readBigUInt64LE(CIRCULATING_TICKET_BALANCE_OFFSET);
+  const emergencyCoolingDown = data.readBigUInt64LE(EMERGENCY_COOLING_DOWN_OFFSET);
+  if (msolSupply === 0n) {
+    throw new Error("Marinade State has zero mSOL supply");
+  }
+  const underControl = totalActiveBalance + delayedUnstakeCoolingDown + emergencyCoolingDown + availableReserveBalance;
+  if (underControl > U64_MAX) {
+    throw new Error("Marinade virtual staked balance overflow");
+  }
+  const totalVirtualStakedLamports = underControl > circulatingTicketBalance ? underControl - circulatingTicketBalance : 0n;
+  const msolPrice = new BigNumber3__default.default(totalVirtualStakedLamports.toString()).div(msolSupply.toString());
+  if (!msolPrice.gt(0) || msolPrice.gte(MAX_MSOL_SOL_RATE)) {
+    throw new Error(`Marinade mSOL/SOL rate out of bounds: ${msolPrice.toString()}`);
+  }
+  return { msolPrice };
+}
+new web3_js.PublicKey(
+  "SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy"
+);
+new web3_js.PublicKey(
+  "SP12tWFxD9oJsVWNavTTBZvMbA6gkAmxtVgxdqvyvhY"
+);
+new web3_js.PublicKey(
+  "SPMBzsVUuoHA4Jm6KunbsotaahvVikZs1JyTW6iJvbn"
+);
+var ACCOUNT_TYPE_STAKE_POOL = 1;
+var TOTAL_LAMPORTS_OFFSET = 258;
+var POOL_TOKEN_SUPPLY_OFFSET = 266;
+var LAST_UPDATE_EPOCH_OFFSET = 274;
+var MAX_LST_SOL_RATE = 3;
+function decodeStakePool(data) {
+  if (data.length < LAST_UPDATE_EPOCH_OFFSET + 8) {
+    throw new Error(`Invalid StakePool account size: ${data.length}`);
+  }
+  if (data[0] !== ACCOUNT_TYPE_STAKE_POOL) {
+    throw new Error(`Invalid StakePool account type: ${data[0]}`);
+  }
+  const totalLamports = data.readBigUInt64LE(TOTAL_LAMPORTS_OFFSET);
+  const poolTokenSupply = data.readBigUInt64LE(POOL_TOKEN_SUPPLY_OFFSET);
+  const lastUpdateEpoch = Number(data.readBigUInt64LE(LAST_UPDATE_EPOCH_OFFSET));
+  if (poolTokenSupply === 0n) {
+    throw new Error("StakePool has zero token supply");
+  }
+  const exchangeRate = new BigNumber3__default.default(totalLamports.toString()).div(
+    new BigNumber3__default.default(poolTokenSupply.toString())
+  );
+  if (!exchangeRate.gt(0) || exchangeRate.gte(MAX_LST_SOL_RATE)) {
+    throw new Error(`StakePool LST/SOL rate out of bounds: ${exchangeRate.toString()}`);
+  }
+  return {
+    totalLamports,
+    poolTokenSupply,
+    lastUpdateEpoch,
+    exchangeRate
+  };
+}
+
+// src/services/price/utils/multiplier-data.utils.ts
+var PT_MAX_MATURITY_HORIZON_SECONDS = 5 * 365 * 24 * 60 * 60;
+var MAX_SY_EXCHANGE_RATE = new BigNumber3__default.default("18446744073709551615").div(1e12);
+var MAX_STAKE_POOL_EPOCH_LAG = 1;
+function multiplierAccountKey(bank) {
+  switch (bank.config.oracleSetup) {
+    case "PythMSOL" /* PythMSOL */:
+    case "PythLST" /* PythLST */:
+    case "PTPyth" /* PTPyth */:
+      return bank.config.oracleKeys[1];
+    case "KaminoMSOL" /* KaminoMSOL */:
+    case "JuplendMSOL" /* JuplendMSOL */:
+    case "KaminoLST" /* KaminoLST */:
+    case "JuplendLST" /* JuplendLST */:
+      return bank.config.oracleKeys[2];
+    case "PTFixed" /* PTFixed */:
+      return bank.config.oracleKeys[0];
+    default:
+      return void 0;
+  }
+}
+function getOracleMultiplierBankInput(bank) {
+  const accountKey = multiplierAccountKey(bank);
+  if (!accountKey) return void 0;
+  const isPt = bank.config.oracleSetup === "PTPyth" /* PTPyth */ || bank.config.oracleSetup === "PTFixed" /* PTFixed */;
+  return {
+    bankAddress: bank.address.toBase58(),
+    oracleSetup: bank.config.oracleSetup,
+    multiplierAccountKey: accountKey.toBase58(),
+    fixedPrice: isPt ? bank.config.fixedPrice : void 0
+  };
+}
+function decodeMultiplierAccount(data) {
+  try {
+    const vault = decodeExponentVault(data);
+    return {
+      kind: "exponentVault",
+      startTs: vault.startTs,
+      duration: vault.duration,
+      syForPt: vault.syForPt.toString(),
+      ptSupply: vault.ptSupply.toString(),
+      lastSeenSyExchangeRate: vault.lastSeenSyExchangeRate.toString(),
+      allTimeHighSyExchangeRate: vault.allTimeHighSyExchangeRate.toString()
+    };
+  } catch {
+  }
+  try {
+    return { kind: "marinade", msolPrice: decodeMarinadeState(data).msolPrice.toString() };
+  } catch {
+  }
+  try {
+    const pool = decodeStakePool(data);
+    return {
+      kind: "stakePool",
+      exchangeRate: pool.exchangeRate.toString(),
+      lastUpdateEpoch: pool.lastUpdateEpoch
+    };
+  } catch {
+  }
+  return void 0;
+}
+function computePtMultiplier(vault, startPrice, nowSeconds) {
+  const maturity = vault.startTs + vault.duration;
+  if (vault.duration <= 0 || maturity > nowSeconds + PT_MAX_MATURITY_HORIZON_SECONDS) {
+    throw new Error("Exponent vault has an invalid maturity schedule");
+  }
+  if (!vault.lastSeenSyExchangeRate.gt(0) || vault.lastSeenSyExchangeRate.gt(MAX_SY_EXCHANGE_RATE)) {
+    throw new Error("Exponent vault SY exchange rate out of bounds");
+  }
+  if (vault.ptSupply === 0n) {
+    throw new Error("Exponent vault has zero PT supply");
+  }
+  if (vault.lastSeenSyExchangeRate.lt(vault.allTimeHighSyExchangeRate)) {
+    throw new Error("Exponent vault is in emergency mode");
+  }
+  let expectedRate;
+  if (nowSeconds <= vault.startTs) {
+    expectedRate = startPrice;
+  } else if (nowSeconds >= maturity) {
+    expectedRate = new BigNumber3__default.default(1);
+  } else {
+    const progress = new BigNumber3__default.default(nowSeconds - vault.startTs).div(vault.duration);
+    expectedRate = startPrice.plus(new BigNumber3__default.default(1).minus(startPrice).times(progress));
+  }
+  const syPerPt = new BigNumber3__default.default(vault.syForPt.toString()).div(
+    new BigNumber3__default.default(vault.ptSupply.toString())
+  );
+  const redemptionCap = syPerPt.times(vault.lastSeenSyExchangeRate);
+  return BigNumber3__default.default.min(expectedRate, redemptionCap);
+}
+function computeOracleMultiplier(input, state, ctx) {
+  switch (input.oracleSetup) {
+    case "PythMSOL" /* PythMSOL */:
+    case "KaminoMSOL" /* KaminoMSOL */:
+    case "JuplendMSOL" /* JuplendMSOL */:
+      if (state.kind !== "marinade") throw new Error(`Expected Marinade state, got ${state.kind}`);
+      return Number(state.msolPrice);
+    case "PythLST" /* PythLST */:
+    case "KaminoLST" /* KaminoLST */:
+    case "JuplendLST" /* JuplendLST */:
+      if (state.kind !== "stakePool") throw new Error(`Expected stake pool, got ${state.kind}`);
+      if (ctx.currentEpoch - state.lastUpdateEpoch > MAX_STAKE_POOL_EPOCH_LAG) {
+        throw new Error(
+          `Stale stake pool (last updated epoch ${state.lastUpdateEpoch}, current ${ctx.currentEpoch})`
+        );
+      }
+      return Number(state.exchangeRate);
+    case "PTPyth" /* PTPyth */:
+    case "PTFixed" /* PTFixed */:
+      if (state.kind !== "exponentVault") {
+        throw new Error(`Expected Exponent vault, got ${state.kind}`);
+      }
+      if (!input.fixedPrice) throw new Error("Missing fixedPrice for PT bank");
+      return computePtMultiplier(
+        {
+          startTs: state.startTs,
+          duration: state.duration,
+          syForPt: BigInt(state.syForPt),
+          ptSupply: BigInt(state.ptSupply),
+          lastSeenSyExchangeRate: new BigNumber3__default.default(state.lastSeenSyExchangeRate),
+          allTimeHighSyExchangeRate: new BigNumber3__default.default(state.allTimeHighSyExchangeRate)
+        },
+        input.fixedPrice,
+        ctx.nowSeconds
+      ).toNumber();
+    default:
+      throw new Error(`Oracle setup ${input.oracleSetup} is not multiplier-priced`);
+  }
+}
+function computeOracleMultipliers(inputs, accountStates, nowSeconds = Math.floor(Date.now() / 1e3)) {
+  const multiplierByBank = {};
+  const ctx = { currentEpoch: accountStates.currentEpoch, nowSeconds };
+  for (const input of inputs) {
+    const state = accountStates.states[input.multiplierAccountKey];
+    if (!state) {
+      console.error(`Missing multiplier account for bank ${input.bankAddress}`);
+      continue;
+    }
+    try {
+      multiplierByBank[input.bankAddress] = computeOracleMultiplier(input, state, ctx);
+    } catch (e) {
+      console.error(`Failed to compute multiplier for bank ${input.bankAddress}`, e);
+    }
+  }
+  return multiplierByBank;
+}
 async function makeSmartCrankSwbFeedIx(params) {
   const crankResult = await computeSmartCrank(params);
   if (crankResult.uncrankableLiabilities.length > 0) {
@@ -75244,84 +75469,6 @@ function decodeScopePriceAtIndex(data, entryIndex) {
     unixTimestamp: Number(unixTimestamp)
   };
 }
-new web3_js.PublicKey("MarBmsSgKXdrN1egZf5sqe1TMai9K1rChYNDJgjq7aD");
-var MARINADE_STATE_DISCRIMINATOR = Buffer.from([216, 146, 107, 94, 104, 75, 182, 177]);
-var DELAYED_UNSTAKE_COOLING_DOWN_OFFSET = 226;
-var TOTAL_ACTIVE_BALANCE_OFFSET = 376;
-var AVAILABLE_RESERVE_BALANCE_OFFSET = 496;
-var MSOL_SUPPLY_OFFSET = 504;
-var CIRCULATING_TICKET_BALANCE_OFFSET = 528;
-var EMERGENCY_COOLING_DOWN_OFFSET = 568;
-var MARINADE_STATE_MIN_SIZE = EMERGENCY_COOLING_DOWN_OFFSET + 8;
-var U64_MAX = (1n << 64n) - 1n;
-var MAX_MSOL_SOL_RATE = 3;
-function decodeMarinadeState(data) {
-  if (data.length < MARINADE_STATE_MIN_SIZE) {
-    throw new Error(`Invalid Marinade State account size: ${data.length}`);
-  }
-  if (!data.subarray(0, 8).equals(MARINADE_STATE_DISCRIMINATOR)) {
-    throw new Error("Invalid Marinade State discriminator");
-  }
-  const delayedUnstakeCoolingDown = data.readBigUInt64LE(DELAYED_UNSTAKE_COOLING_DOWN_OFFSET);
-  const totalActiveBalance = data.readBigUInt64LE(TOTAL_ACTIVE_BALANCE_OFFSET);
-  const availableReserveBalance = data.readBigUInt64LE(AVAILABLE_RESERVE_BALANCE_OFFSET);
-  const msolSupply = data.readBigUInt64LE(MSOL_SUPPLY_OFFSET);
-  const circulatingTicketBalance = data.readBigUInt64LE(CIRCULATING_TICKET_BALANCE_OFFSET);
-  const emergencyCoolingDown = data.readBigUInt64LE(EMERGENCY_COOLING_DOWN_OFFSET);
-  if (msolSupply === 0n) {
-    throw new Error("Marinade State has zero mSOL supply");
-  }
-  const underControl = totalActiveBalance + delayedUnstakeCoolingDown + emergencyCoolingDown + availableReserveBalance;
-  if (underControl > U64_MAX) {
-    throw new Error("Marinade virtual staked balance overflow");
-  }
-  const totalVirtualStakedLamports = underControl > circulatingTicketBalance ? underControl - circulatingTicketBalance : 0n;
-  const msolPrice = new BigNumber3__default.default(totalVirtualStakedLamports.toString()).div(msolSupply.toString());
-  if (!msolPrice.gt(0) || msolPrice.gte(MAX_MSOL_SOL_RATE)) {
-    throw new Error(`Marinade mSOL/SOL rate out of bounds: ${msolPrice.toString()}`);
-  }
-  return { msolPrice };
-}
-new web3_js.PublicKey(
-  "SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy"
-);
-new web3_js.PublicKey(
-  "SP12tWFxD9oJsVWNavTTBZvMbA6gkAmxtVgxdqvyvhY"
-);
-new web3_js.PublicKey(
-  "SPMBzsVUuoHA4Jm6KunbsotaahvVikZs1JyTW6iJvbn"
-);
-var ACCOUNT_TYPE_STAKE_POOL = 1;
-var TOTAL_LAMPORTS_OFFSET = 258;
-var POOL_TOKEN_SUPPLY_OFFSET = 266;
-var LAST_UPDATE_EPOCH_OFFSET = 274;
-var MAX_LST_SOL_RATE = 3;
-function decodeStakePool(data) {
-  if (data.length < LAST_UPDATE_EPOCH_OFFSET + 8) {
-    throw new Error(`Invalid StakePool account size: ${data.length}`);
-  }
-  if (data[0] !== ACCOUNT_TYPE_STAKE_POOL) {
-    throw new Error(`Invalid StakePool account type: ${data[0]}`);
-  }
-  const totalLamports = data.readBigUInt64LE(TOTAL_LAMPORTS_OFFSET);
-  const poolTokenSupply = data.readBigUInt64LE(POOL_TOKEN_SUPPLY_OFFSET);
-  const lastUpdateEpoch = Number(data.readBigUInt64LE(LAST_UPDATE_EPOCH_OFFSET));
-  if (poolTokenSupply === 0n) {
-    throw new Error("StakePool has zero token supply");
-  }
-  const exchangeRate = new BigNumber3__default.default(totalLamports.toString()).div(
-    new BigNumber3__default.default(poolTokenSupply.toString())
-  );
-  if (!exchangeRate.gt(0) || exchangeRate.gte(MAX_LST_SOL_RATE)) {
-    throw new Error(`StakePool LST/SOL rate out of bounds: ${exchangeRate.toString()}`);
-  }
-  return {
-    totalLamports,
-    poolTokenSupply,
-    lastUpdateEpoch,
-    exchangeRate
-  };
-}
 var GAMMA_VAULT_PROGRAM_ID = new web3_js.PublicKey(
   "GaMmanX9i4jGmqDZZD2tbD6B2v9p21btenPneMXnTczV"
 );
@@ -85171,144 +85318,71 @@ var fetchScopeOraclePricesFromChain = async (requestKeys, connection) => {
   }
   return oraclePriceByRequestKey;
 };
-var PT_MAX_MATURITY_HORIZON_SECONDS = 5 * 365 * 24 * 60 * 60;
-var MAX_SY_EXCHANGE_RATE = new BigNumber3__default.default("18446744073709551615").div(1e12);
-var MAX_STAKE_POOL_EPOCH_LAG = 1;
-function multiplierAccountKey(bank) {
-  switch (bank.config.oracleSetup) {
-    case "PythMSOL" /* PythMSOL */:
-    case "PythLST" /* PythLST */:
-    case "PTPyth" /* PTPyth */:
-      return bank.config.oracleKeys[1];
-    case "KaminoMSOL" /* KaminoMSOL */:
-    case "JuplendMSOL" /* JuplendMSOL */:
-    case "KaminoLST" /* KaminoLST */:
-    case "JuplendLST" /* JuplendLST */:
-      return bank.config.oracleKeys[2];
-    case "PTFixed" /* PTFixed */:
-      return bank.config.oracleKeys[0];
-    default:
-      return void 0;
-  }
-}
-function computePtMultiplier(vault, startPrice, nowSeconds) {
-  const maturity = vault.startTs + vault.duration;
-  if (vault.duration <= 0 || maturity > nowSeconds + PT_MAX_MATURITY_HORIZON_SECONDS) {
-    throw new Error("Exponent vault has an invalid maturity schedule");
-  }
-  if (!vault.lastSeenSyExchangeRate.gt(0) || vault.lastSeenSyExchangeRate.gt(MAX_SY_EXCHANGE_RATE)) {
-    throw new Error("Exponent vault SY exchange rate out of bounds");
-  }
-  if (vault.ptSupply === 0n) {
-    throw new Error("Exponent vault has zero PT supply");
-  }
-  if (vault.lastSeenSyExchangeRate.lt(vault.allTimeHighSyExchangeRate)) {
-    throw new Error("Exponent vault is in emergency mode");
-  }
-  let expectedRate;
-  if (nowSeconds <= vault.startTs) {
-    expectedRate = startPrice;
-  } else if (nowSeconds >= maturity) {
-    expectedRate = new BigNumber3__default.default(1);
-  } else {
-    const progress = new BigNumber3__default.default(nowSeconds - vault.startTs).div(vault.duration);
-    expectedRate = startPrice.plus(new BigNumber3__default.default(1).minus(startPrice).times(progress));
-  }
-  const syPerPt = new BigNumber3__default.default(vault.syForPt.toString()).div(
-    new BigNumber3__default.default(vault.ptSupply.toString())
-  );
-  const redemptionCap = syPerPt.times(vault.lastSeenSyExchangeRate);
-  return BigNumber3__default.default.min(expectedRate, redemptionCap);
-}
+
+// src/services/price/services/oracle-multiplier.service.ts
 var fetchOracleMultipliers = async (banks, opts) => {
-  const multipliedBanks = banks.filter((bank) => multiplierAccountKey(bank) !== void 0);
-  if (!multipliedBanks.length) {
+  const inputs = banks.map(getOracleMultiplierBankInput).filter((input) => input !== void 0);
+  if (!inputs.length) {
     return {};
   }
   if (!opts) {
     console.warn(
-      `fetchOracleMultipliers: no oracleMultiplierOpts provided; ${multipliedBanks.length} multiplier-priced bank(s) will have zero prices`
+      `fetchOracleMultipliers: no oracleMultiplierOpts provided; ${inputs.length} multiplier-priced bank(s) will have zero prices`
     );
     return {};
   }
   if (opts.mode === "api") {
-    return fetchOracleMultipliersFromAPI(
-      multipliedBanks.map((bank) => bank.address.toBase58()),
-      opts.multiplierData.endpoint,
-      { queryKey: opts.multiplierData.queryKey }
-    );
+    return fetchOracleMultipliersFromAPI(inputs, opts.multiplierData.endpoint, {
+      queryKey: opts.multiplierData.queryKey
+    });
   }
-  return fetchOracleMultipliersFromChain(multipliedBanks, opts.connection);
+  return fetchOracleMultipliersFromChain(inputs, opts.connection);
 };
-var fetchOracleMultipliersFromAPI = async (bankAddresses, apiEndpoint, opts) => {
-  const queryKey = opts?.queryKey ?? "bankAddresses";
-  const response = await fetch(`${apiEndpoint}?${queryKey}=${bankAddresses.join(",")}`);
+var fetchOracleMultipliersFromAPI = async (inputs, apiEndpoint, opts) => {
+  const accountStates = await fetchMultiplierAccountStatesFromAPI(
+    inputs.map((input) => input.multiplierAccountKey),
+    apiEndpoint,
+    opts
+  );
+  return computeOracleMultipliers(inputs, accountStates);
+};
+var fetchOracleMultipliersFromChain = async (inputs, connection) => {
+  const accountStates = await fetchMultiplierAccountStates(
+    inputs.map((input) => input.multiplierAccountKey),
+    connection
+  );
+  return computeOracleMultipliers(inputs, accountStates);
+};
+var fetchMultiplierAccountStatesFromAPI = async (accountKeys, apiEndpoint, opts) => {
+  const queryKey = opts?.queryKey ?? "multiplierAccounts";
+  const uniqueKeys = Array.from(new Set(accountKeys));
+  const response = await fetch(`${apiEndpoint}?${queryKey}=${uniqueKeys.join(",")}`);
   if (!response.ok) {
     throw new Error("Failed to fetch price multiplier data");
   }
   const { data } = await response.json();
-  return Object.fromEntries(
-    Object.entries(data).map(([bankAddress, multiplier]) => [bankAddress, Number(multiplier)]).filter(([, multiplier]) => Number.isFinite(multiplier))
-  );
+  return data;
 };
-var fetchOracleMultipliersFromChain = async (multipliedBanks, connection) => {
-  const accountKeyByBank = new Map(
-    multipliedBanks.map((bank) => [bank.address.toBase58(), multiplierAccountKey(bank).toBase58()])
-  );
-  const uniqueAccountKeys = Array.from(new Set(accountKeyByBank.values()));
-  const accountAis = await chunkedGetRawMultipleAccountInfoOrderedWithNulls(
-    connection,
-    uniqueAccountKeys
-  );
-  const isLstSetup = (setup) => setup === "PythLST" /* PythLST */ || setup === "KaminoLST" /* KaminoLST */ || setup === "JuplendLST" /* JuplendLST */;
-  const currentEpoch = multipliedBanks.some((bank) => isLstSetup(bank.config.oracleSetup)) ? (await connection.getEpochInfo()).epoch : 0;
-  const accountDataByKey = {};
-  uniqueAccountKeys.forEach((accountKey, index) => {
-    accountDataByKey[accountKey] = accountAis[index]?.data;
-  });
-  const multiplierByBank = {};
-  const nowSeconds = Math.floor(Date.now() / 1e3);
-  for (const bank of multipliedBanks) {
-    const bankAddress = bank.address.toBase58();
-    const data = accountDataByKey[accountKeyByBank.get(bankAddress)];
+var fetchMultiplierAccountStates = async (accountKeys, connection) => {
+  const uniqueKeys = Array.from(new Set(accountKeys));
+  const accountAis = await chunkedGetRawMultipleAccountInfoOrderedWithNulls(connection, uniqueKeys);
+  const states = {};
+  uniqueKeys.forEach((accountKey, index) => {
+    const data = accountAis[index]?.data;
     if (!data) {
-      console.error(`Missing multiplier account for bank ${bankAddress}`);
-      continue;
+      console.error(`Missing multiplier account ${accountKey}`);
+      return;
     }
-    try {
-      switch (bank.config.oracleSetup) {
-        case "PythMSOL" /* PythMSOL */:
-        case "KaminoMSOL" /* KaminoMSOL */:
-        case "JuplendMSOL" /* JuplendMSOL */:
-          multiplierByBank[bankAddress] = decodeMarinadeState(data).msolPrice.toNumber();
-          break;
-        case "PythLST" /* PythLST */:
-        case "KaminoLST" /* KaminoLST */:
-        case "JuplendLST" /* JuplendLST */: {
-          const stakePool = decodeStakePool(data);
-          if (currentEpoch - stakePool.lastUpdateEpoch > MAX_STAKE_POOL_EPOCH_LAG) {
-            console.error(
-              `Stale stake pool for bank ${bankAddress} (last updated epoch ${stakePool.lastUpdateEpoch}, current ${currentEpoch})`
-            );
-            continue;
-          }
-          multiplierByBank[bankAddress] = stakePool.exchangeRate.toNumber();
-          break;
-        }
-        case "PTPyth" /* PTPyth */:
-        case "PTFixed" /* PTFixed */:
-          multiplierByBank[bankAddress] = computePtMultiplier(
-            decodeExponentVault(data),
-            bank.config.fixedPrice,
-            nowSeconds
-          ).toNumber();
-          break;
-      }
-    } catch (e) {
-      console.error(`Failed to compute multiplier for bank ${bankAddress}`, e);
+    const state = decodeMultiplierAccount(data);
+    if (!state) {
+      console.error(`Unrecognized multiplier account ${accountKey}`);
+      return;
     }
-  }
-  return multiplierByBank;
+    states[accountKey] = state;
+  });
+  const hasStakePool = Object.values(states).some((state) => state.kind === "stakePool");
+  const currentEpoch = hasStakePool ? (await connection.getEpochInfo()).epoch : 0;
+  return { states, currentEpoch };
 };
 var fetchOracleData = async (banks, opts) => {
   const { zeroOracleBanks, isolatedAssetBanks, collateralAssetBanks, fixedAssetBanks } = classifyBanksForOracleStrategy(banks);
@@ -89584,6 +89658,8 @@ exports.computeMaxDepositForBank = computeMaxDepositForBank;
 exports.computeMaxLeverage = computeMaxLeverage;
 exports.computeMaxWithdrawForBank = computeMaxWithdrawForBank;
 exports.computeNetApy = computeNetApy;
+exports.computeOracleMultiplier = computeOracleMultiplier;
+exports.computeOracleMultipliers = computeOracleMultipliers;
 exports.computeProjectedActiveBalancesNoCpi = computeProjectedActiveBalancesNoCpi;
 exports.computeProjectedActiveBanksNoCpi = computeProjectedActiveBanksNoCpi;
 exports.computePtMultiplier = computePtMultiplier;
@@ -89607,6 +89683,7 @@ exports.createEmptyBalance = createEmptyBalance;
 exports.decodeAccountRaw = decodeAccountRaw;
 exports.decodeBankRaw = decodeBankRaw;
 exports.decodeInstruction = decodeInstruction;
+exports.decodeMultiplierAccount = decodeMultiplierAccount;
 exports.decompileV0Transaction = decompileV0Transaction;
 exports.deriveBankEmissionsAuth = deriveBankEmissionsAuth;
 exports.deriveBankEmissionsVault = deriveBankEmissionsVault;
@@ -89650,6 +89727,8 @@ exports.fetchMarginfiAccountAddresses = fetchMarginfiAccountAddresses;
 exports.fetchMarginfiAccountAddressesHoldingBank = fetchMarginfiAccountAddressesHoldingBank;
 exports.fetchMarginfiAccountData = fetchMarginfiAccountData;
 exports.fetchMultipleBanks = fetchMultipleBanks;
+exports.fetchMultiplierAccountStates = fetchMultiplierAccountStates;
+exports.fetchMultiplierAccountStatesFromAPI = fetchMultiplierAccountStatesFromAPI;
 exports.fetchNativeStakeAccounts = fetchNativeStakeAccounts;
 exports.fetchOracleData = fetchOracleData;
 exports.fetchOracleMultipliers = fetchOracleMultipliers;
@@ -89710,6 +89789,7 @@ exports.getKaminoStatesDto = getKaminoStatesDto;
 exports.getLiabilityQuantity = getLiabilityQuantity;
 exports.getLiabilityShares = getLiabilityShares;
 exports.getLiabilityWeight = getLiabilityWeight;
+exports.getOracleMultiplierBankInput = getOracleMultiplierBankInput;
 exports.getOracleSourceFromBank = getOracleSourceFromBank;
 exports.getOracleSourceFromOracleSetup = getOracleSourceFromOracleSetup;
 exports.getOracleSourceNameFromKey = getOracleSourceNameFromKey;