@0dotxyz/p0-ts-sdk 2.7.4 → 2.8.0-alpha.1

package/dist/index.cjs

@@ -13265,6 +13265,26 @@ var marginfi_0_1_10_default = {
       code: 6604,
       name: "CircuitBreakerPriceJump",
       msg: "Oracle price deviates too far from the circuit breaker reference; action rejected"
+    },
+    {
+      code: 6700,
+      name: "ScopeInvalidAccount",
+      msg: "Scope oracle account is not owned by the Scope program or is malformed"
+    },
+    {
+      code: 6701,
+      name: "ScopeInvalidEntry",
+      msg: "Scope entry index is out of range or the entry has never been refreshed"
+    },
+    {
+      code: 6702,
+      name: "ScopeStalePrice",
+      msg: "Scope price is stale"
+    },
+    {
+      code: 6703,
+      name: "UseConfigureBankOracleScope",
+      msg: "Use lending_pool_configure_bank_oracle_scope; Scope requires an entry index"
     }
   ],
   types: [
@@ -14354,13 +14374,13 @@ var marginfi_0_1_10_default = {
             type: "u16"
           },
           {
-            name: "_padding0",
-            type: {
-              array: [
-                "u8",
-                2
-              ]
-            }
+            name: "scope_entry_index",
+            docs: [
+              "Entry index into the Scope OraclePrices price list. Only read when",
+              "oracle_setup == OracleSetup::Scope; ignored (and zero) for every other setup.",
+              "Occupies what was previously _padding0, so the layout is unchanged."
+            ],
+            type: "u16"
           },
           {
             name: "oracle_max_confidence",
@@ -19311,6 +19331,144 @@ var marginfi_0_1_10_default = {
           },
           {
             name: "FixedJuplend"
+          },
+          {
+            name: "Scope"
+          },
+          {
+            name: "PythMSOL"
+          },
+          {
+            name: "KaminoMSOL"
+          },
+          {
+            name: "JuplendMSOL"
+          },
+          {
+            name: "PythLST"
+          },
+          {
+            name: "KaminoLST"
+          },
+          {
+            name: "JuplendLST"
+          },
+          {
+            name: "PTPyth"
+          },
+          {
+            name: "PTFixed"
+          },
+          {
+            name: "Reserved27"
+          },
+          {
+            name: "Reserved28"
+          },
+          {
+            name: "Reserved29"
+          },
+          {
+            name: "Reserved30"
+          },
+          {
+            name: "Reserved31"
+          },
+          {
+            name: "Reserved32"
+          },
+          {
+            name: "Reserved33"
+          },
+          {
+            name: "Reserved34"
+          },
+          {
+            name: "Reserved35"
+          },
+          {
+            name: "Reserved36"
+          },
+          {
+            name: "Reserved37"
+          },
+          {
+            name: "Reserved38"
+          },
+          {
+            name: "Reserved39"
+          },
+          {
+            name: "Reserved40"
+          },
+          {
+            name: "Reserved41"
+          },
+          {
+            name: "Reserved42"
+          },
+          {
+            name: "Reserved43"
+          },
+          {
+            name: "Reserved44"
+          },
+          {
+            name: "Reserved45"
+          },
+          {
+            name: "Reserved46"
+          },
+          {
+            name: "Reserved47"
+          },
+          {
+            name: "Reserved48"
+          },
+          {
+            name: "Reserved49"
+          },
+          {
+            name: "Reserved50"
+          },
+          {
+            name: "Reserved51"
+          },
+          {
+            name: "Reserved52"
+          },
+          {
+            name: "Reserved53"
+          },
+          {
+            name: "Reserved54"
+          },
+          {
+            name: "Reserved55"
+          },
+          {
+            name: "Reserved56"
+          },
+          {
+            name: "Reserved57"
+          },
+          {
+            name: "Reserved58"
+          },
+          {
+            name: "Reserved59"
+          },
+          {
+            name: "Reserved60"
+          },
+          {
+            name: "Reserved61"
+          },
+          {
+            name: "Reserved62"
+          },
+          {
+            name: "Reserved63"
           }
         ]
       }
@@ -20731,6 +20889,16 @@ var OracleSetup = /* @__PURE__ */ ((OracleSetup3) => {
   OracleSetup3["JuplendPythPull"] = "JuplendPythPull";
   OracleSetup3["JuplendSwitchboardPull"] = "JuplendSwitchboardPull";
   OracleSetup3["FixedJuplend"] = "FixedJuplend";
+  OracleSetup3["Scope"] = "Scope";
+  OracleSetup3["PythMSOL"] = "PythMSOL";
+  OracleSetup3["KaminoMSOL"] = "KaminoMSOL";
+  OracleSetup3["JuplendMSOL"] = "JuplendMSOL";
+  OracleSetup3["PythLST"] = "PythLST";
+  OracleSetup3["KaminoLST"] = "KaminoLST";
+  OracleSetup3["JuplendLST"] = "JuplendLST";
+  OracleSetup3["PTPyth"] = "PTPyth";
+  OracleSetup3["PTFixed"] = "PTFixed";
+  OracleSetup3["Unknown"] = "Unknown";
   return OracleSetup3;
 })(OracleSetup || {});
 var AssetTag = /* @__PURE__ */ ((AssetTag3) => {
@@ -21792,8 +21960,26 @@ function serializeOracleSetupToIndex(oracleSetup) {
       return 16;
     case "FixedJuplend" /* FixedJuplend */:
       return 17;
+    case "Scope" /* Scope */:
+      return 18;
+    case "PythMSOL" /* PythMSOL */:
+      return 19;
+    case "KaminoMSOL" /* KaminoMSOL */:
+      return 20;
+    case "JuplendMSOL" /* JuplendMSOL */:
+      return 21;
+    case "PythLST" /* PythLST */:
+      return 22;
+    case "KaminoLST" /* KaminoLST */:
+      return 23;
+    case "JuplendLST" /* JuplendLST */:
+      return 24;
+    case "PTPyth" /* PTPyth */:
+      return 25;
+    case "PTFixed" /* PTFixed */:
+      return 26;
     default:
-      return 0;
+      throw new Error(`Cannot serialize oracle setup "${oracleSetup}"`);
   }
 }
 function serializeOracleSetup(oracleSetup) {
@@ -21834,6 +22020,24 @@ function serializeOracleSetup(oracleSetup) {
       return { juplendSwitchboardPull: {} };
     case "FixedJuplend" /* FixedJuplend */:
       return { fixedJuplend: {} };
+    case "Scope" /* Scope */:
+      return { scope: {} };
+    case "PythMSOL" /* PythMSOL */:
+      return { pythMsol: {} };
+    case "KaminoMSOL" /* KaminoMSOL */:
+      return { kaminoMsol: {} };
+    case "JuplendMSOL" /* JuplendMSOL */:
+      return { juplendMsol: {} };
+    case "PythLST" /* PythLST */:
+      return { pythLst: {} };
+    case "KaminoLST" /* KaminoLST */:
+      return { kaminoLst: {} };
+    case "JuplendLST" /* JuplendLST */:
+      return { juplendLst: {} };
+    case "PTPyth" /* PTPyth */:
+      return { ptPyth: {} };
+    case "PTFixed" /* PTFixed */:
+      return { ptFixed: {} };
     default:
       throw new Error(`Invalid oracle setup "${oracleSetup}"`);
   }
@@ -21947,7 +22151,8 @@ function toBankConfigDto(bankConfig) {
     interestRateConfig: toInterestRateConfigDto(bankConfig.interestRateConfig),
     configFlags: bankConfig.configFlags,
     oracleMaxConfidence: bankConfig.oracleMaxConfidence,
-    fixedPrice: bankConfig.fixedPrice.toString()
+    fixedPrice: bankConfig.fixedPrice.toString(),
+    scopeEntryIndex: bankConfig.scopeEntryIndex
   };
 }
 function toInterestRateConfigDto(interestRateConfig) {
@@ -22053,7 +22258,8 @@ function bankConfigToBankConfigRaw(config) {
     totalAssetValueInitLimit: new BN9__default.default(config.totalAssetValueInitLimit.toString()),
     oracleMaxAge: config.oracleMaxAge,
     oracleMaxConfidence: config.oracleMaxConfidence,
-    fixedPrice: bigNumberToWrappedI80F48(config.fixedPrice)
+    fixedPrice: bigNumberToWrappedI80F48(config.fixedPrice),
+    scopeEntryIndex: config.scopeEntryIndex
   };
 }
 function bankConfigRawToDto(bankConfigRaw) {
@@ -22074,7 +22280,8 @@ function bankConfigRawToDto(bankConfigRaw) {
     interestRateConfig: bankConfigRaw.interestRateConfig,
     configFlags: bankConfigRaw.configFlags,
     oracleMaxConfidence: bankConfigRaw.oracleMaxConfidence,
-    fixedPrice: bankConfigRaw.fixedPrice
+    fixedPrice: bankConfigRaw.fixedPrice,
+    scopeEntryIndex: bankConfigRaw.scopeEntryIndex
   };
 }
 
@@ -22362,7 +22569,8 @@ function dtoToBankConfig(bankConfigDto) {
     oracleMaxAge: bankConfigDto.oracleMaxAge,
     interestRateConfig: dtoToInterestRateConfig(bankConfigDto.interestRateConfig),
     oracleMaxConfidence: bankConfigDto.oracleMaxConfidence,
-    fixedPrice: new BigNumber3__default.default(bankConfigDto.fixedPrice)
+    fixedPrice: new BigNumber3__default.default(bankConfigDto.fixedPrice),
+    scopeEntryIndex: bankConfigDto.scopeEntryIndex ?? 0
   };
 }
 function dtoToInterestRateConfig(interestRateConfigDto) {
@@ -22475,7 +22683,8 @@ function dtoToBankConfigRaw(bankConfigDto) {
     oracleMaxAge: bankConfigDto.oracleMaxAge,
     interestRateConfig: bankConfigDto.interestRateConfig,
     oracleMaxConfidence: bankConfigDto.oracleMaxConfidence,
-    fixedPrice: bankConfigDto.fixedPrice
+    fixedPrice: bankConfigDto.fixedPrice,
+    scopeEntryIndex: bankConfigDto.scopeEntryIndex ?? 0
   };
 }
 function parseBankConfigRaw(bankConfigRaw) {
@@ -22492,7 +22701,7 @@ function parseBankConfigRaw(bankConfigRaw) {
   const configFlags = bankConfigRaw.configFlags;
   const oracleSetup = parseOracleSetup(bankConfigRaw.oracleSetup);
   const oracleKeys = bankConfigRaw.oracleKeys;
-  const oracleMaxAge = bankConfigRaw.oracleMaxAge === 0 ? DEFAULT_ORACLE_MAX_AGE : bankConfigRaw.oracleMaxAge;
+  const oracleMaxAge = bankConfigRaw.oracleMaxAge === 0 && oracleSetup !== "Scope" /* Scope */ ? DEFAULT_ORACLE_MAX_AGE : bankConfigRaw.oracleMaxAge;
   const interestRateConfig = {
     insuranceFeeFixedApr: wrappedI80F48toBigNumber(
       bankConfigRaw.interestRateConfig.insuranceFeeFixedApr
@@ -22515,6 +22724,7 @@ function parseBankConfigRaw(bankConfigRaw) {
   };
   const oracleMaxConfidence = bankConfigRaw.oracleMaxConfidence;
   const fixedPrice = wrappedI80F48toBigNumber(bankConfigRaw.fixedPrice);
+  const scopeEntryIndex = bankConfigRaw.scopeEntryIndex ?? 0;
   return {
     assetWeightInit,
     assetWeightMaint,
@@ -22532,7 +22742,8 @@ function parseBankConfigRaw(bankConfigRaw) {
     oracleMaxAge,
     interestRateConfig,
     oracleMaxConfidence,
-    fixedPrice
+    fixedPrice,
+    scopeEntryIndex
   };
 }
 function parseRiskTier(riskTierRaw) {
@@ -22594,18 +22805,36 @@ function parseOracleSetup(oracleSetupRaw) {
       return "SolendPythPull" /* SolendPythPull */;
     case "solendswitchboardpull":
       return "SolendSwitchboardPull" /* SolendSwitchboardPull */;
-    case "FixedKamino":
+    case "fixedkamino":
       return "FixedKamino" /* FixedKamino */;
-    case "FixedDrift":
+    case "fixeddrift":
       return "FixedDrift" /* FixedDrift */;
     case "juplendpythpull":
       return "JuplendPythPull" /* JuplendPythPull */;
     case "juplendswitchboardpull":
       return "JuplendSwitchboardPull" /* JuplendSwitchboardPull */;
-    case "FixedJuplend":
+    case "fixedjuplend":
       return "FixedJuplend" /* FixedJuplend */;
+    case "scope":
+      return "Scope" /* Scope */;
+    case "pythmsol":
+      return "PythMSOL" /* PythMSOL */;
+    case "kaminomsol":
+      return "KaminoMSOL" /* KaminoMSOL */;
+    case "juplendmsol":
+      return "JuplendMSOL" /* JuplendMSOL */;
+    case "pythlst":
+      return "PythLST" /* PythLST */;
+    case "kaminolst":
+      return "KaminoLST" /* KaminoLST */;
+    case "juplendlst":
+      return "JuplendLST" /* JuplendLST */;
+    case "ptpyth":
+      return "PTPyth" /* PTPyth */;
+    case "ptfixed":
+      return "PTFixed" /* PTFixed */;
     default:
-      return "None" /* None */;
+      return "Unknown" /* Unknown */;
   }
 }
 function getActiveEmodeFlags(flags) {
@@ -25736,6 +25965,17 @@ var categorizePythBanks = (banks) => {
   const juplendPythPullBanks = banks.filter(
     (bank) => bank.config.oracleSetup === "JuplendPythPull" /* JuplendPythPull */
   );
+  const pythMultipliedBanks = banks.filter(
+    (bank) => [
+      "PythMSOL" /* PythMSOL */,
+      "KaminoMSOL" /* KaminoMSOL */,
+      "JuplendMSOL" /* JuplendMSOL */,
+      "PythLST" /* PythLST */,
+      "KaminoLST" /* KaminoLST */,
+      "JuplendLST" /* JuplendLST */,
+      "PTPyth" /* PTPyth */
+    ].includes(bank.config.oracleSetup)
+  );
   return {
     pythLegacyBanks,
     pythPushBanks,
@@ -25743,7 +25983,8 @@ var categorizePythBanks = (banks) => {
     pythPushKaminosBanks,
     driftPythPullBanks,
     solendPythPullBanks,
-    juplendPythPullBanks
+    juplendPythPullBanks,
+    pythMultipliedBanks
   };
 };
 var convertVoteAccCoeffsToBankCoeffs = (pythStakedCollateralBanks, validatorVoteAccountByBank, voteAccCoeffs) => {
@@ -25760,7 +26001,7 @@ var extractPythOracleKeys = (pythBanks) => {
   const keys = pythBanks.map((bank) => bank.config.oracleKeys[0].toBase58());
   return [...keys];
 };
-var mapPythBanksToOraclePrices = (pythPushBanks, pythStakedCollateralBanks, oraclePrices, priceCoeffByBank) => {
+var mapPythBanksToOraclePrices = (pythPushBanks, multipliedBanks, oraclePrices, priceCoeffByBank) => {
   const bankOraclePriceMap = /* @__PURE__ */ new Map();
   pythPushBanks.forEach((bank) => {
     const oracleKey = bank.config.oracleKeys[0].toBase58();
@@ -25769,7 +26010,7 @@ var mapPythBanksToOraclePrices = (pythPushBanks, pythStakedCollateralBanks, orac
       bankOraclePriceMap.set(bank.address.toBase58(), oraclePrice);
     }
   });
-  pythStakedCollateralBanks.forEach((bank) => {
+  multipliedBanks.forEach((bank) => {
     const priceCoeff = priceCoeffByBank[bank.address.toBase58()];
     const oracleKey = bank.config.oracleKeys[0]?.toBase58();
     if (oracleKey && priceCoeff !== void 0) {
@@ -25787,7 +26028,7 @@ var mapPythBanksToOraclePrices = (pythPushBanks, pythStakedCollateralBanks, orac
 };
 var adjustPriceComponent = (priceComponent, priceCoeff) => ({
   price: priceComponent.price.multipliedBy(priceCoeff),
-  confidence: priceComponent.confidence,
+  confidence: priceComponent.confidence.multipliedBy(priceCoeff),
   lowestPrice: priceComponent.lowestPrice.multipliedBy(priceCoeff),
   highestPrice: priceComponent.highestPrice.multipliedBy(priceCoeff)
 });
@@ -25839,6 +26080,7 @@ var ORACLE_SOURCES = {
   switchboard: "Switchboard",
   pyth: "Pyth",
   fixed: "Fixed",
+  scope: "Scope",
   unknown: "Unknown"
 };
 function getOracleSourceNameFromKey(oracleSourceKey) {
@@ -25865,14 +26107,25 @@ function getOracleSourceFromOracleSetup(oracleSetup) {
     case "DriftPythPull" /* DriftPythPull */:
     case "SolendPythPull" /* SolendPythPull */:
     case "JuplendPythPull" /* JuplendPythPull */:
+    case "PythMSOL" /* PythMSOL */:
+    case "KaminoMSOL" /* KaminoMSOL */:
+    case "JuplendMSOL" /* JuplendMSOL */:
+    case "PythLST" /* PythLST */:
+    case "KaminoLST" /* KaminoLST */:
+    case "JuplendLST" /* JuplendLST */:
+    case "PTPyth" /* PTPyth */:
       oracleSourceKey = "pyth";
       break;
     case "Fixed" /* Fixed */:
     case "FixedKamino" /* FixedKamino */:
     case "FixedDrift" /* FixedDrift */:
     case "FixedJuplend" /* FixedJuplend */:
+    case "PTFixed" /* PTFixed */:
       oracleSourceKey = "fixed";
       break;
+    case "Scope" /* Scope */:
+      oracleSourceKey = "scope";
+      break;
     default:
       oracleSourceKey = "unknown";
       break;
@@ -27347,6 +27600,19 @@ function computeBankRiskAccountKeys(bank) {
   if (bank.config.assetTag === 3 /* KAMINO */ || bank.config.assetTag === 4 /* DRIFT */ || bank.config.assetTag === 5 /* SOLEND */ || bank.config.assetTag === 6 /* JUPLEND */) {
     keys.push(bank.config.oracleKeys[1]);
   }
+  switch (bank.config.oracleSetup) {
+    case "PythMSOL" /* PythMSOL */:
+    case "PythLST" /* PythLST */:
+    case "PTPyth" /* PTPyth */:
+      keys.push(bank.config.oracleKeys[1]);
+      break;
+    case "KaminoMSOL" /* KaminoMSOL */:
+    case "JuplendMSOL" /* JuplendMSOL */:
+    case "KaminoLST" /* KaminoLST */:
+    case "JuplendLST" /* JuplendLST */:
+      keys.push(bank.config.oracleKeys[2]);
+      break;
+  }
   if (bank.config.assetTag === 2 /* STAKED */) {
     keys.push(bank.config.oracleKeys[1], bank.config.oracleKeys[2]);
     const onrampKey = bank.config.oracleKeys[3];
@@ -72101,7 +72367,9 @@ function decodeExponentVault(data) {
     finalSyExchangeRate: exponentNumberToBigNumber(
       get("final_sy_exchange_rate", "finalSyExchangeRate")
     ),
-    status: Number(get("status", "status") ?? 0)
+    status: Number(get("status", "status") ?? 0),
+    startTs: Number(get("start_ts", "startTs") ?? 0),
+    duration: Number(get("duration", "duration") ?? 0)
   };
 }
 function decodeExponentMarketVault(data) {
@@ -74970,6 +75238,82 @@ function makeRefreshIntegrationBanksIxs(marginfiAccount, bankMap, banksToExclude
     keys: [...kaminoRefreshIxs.keys, ...updateDriftMarketIxs.keys, ...updateJupLendRateIxs.keys]
   };
 }
+new web3_js.PublicKey("HFn8GnPADiny6XqUoWE8uRPPxb29ikn4yTuPa9MF2fWJ");
+var SCOPE_ORACLE_PRICES_DISCRIMINATOR = Buffer.from([89, 128, 118, 221, 6, 72, 180, 146]);
+var SCOPE_MAX_ENTRIES = 512;
+var ENTRIES_OFFSET = 40;
+var DATED_PRICE_SIZE = 56;
+var SCOPE_ORACLE_PRICES_SIZE = ENTRIES_OFFSET + SCOPE_MAX_ENTRIES * DATED_PRICE_SIZE;
+function decodeScopePriceAtIndex(data, entryIndex) {
+  if (data.length !== SCOPE_ORACLE_PRICES_SIZE) {
+    throw new Error(`Invalid Scope OraclePrices account size: ${data.length}`);
+  }
+  if (!data.subarray(0, 8).equals(SCOPE_ORACLE_PRICES_DISCRIMINATOR)) {
+    throw new Error("Invalid Scope OraclePrices discriminator");
+  }
+  if (entryIndex < 0 || entryIndex >= SCOPE_MAX_ENTRIES) {
+    throw new Error(`Scope entry index out of range: ${entryIndex}`);
+  }
+  const offset = ENTRIES_OFFSET + entryIndex * DATED_PRICE_SIZE;
+  const value = data.readBigUInt64LE(offset);
+  const exp = data.readBigUInt64LE(offset + 8);
+  const lastUpdatedSlot = data.readBigUInt64LE(offset + 16);
+  const unixTimestamp = data.readBigUInt64LE(offset + 24);
+  const price = new BigNumber3__default.default(value.toString()).shiftedBy(-Number(exp));
+  return {
+    price,
+    lastUpdatedSlot: Number(lastUpdatedSlot),
+    unixTimestamp: Number(unixTimestamp)
+  };
+}
+new web3_js.PublicKey("MarBmsSgKXdrN1egZf5sqe1TMai9K1rChYNDJgjq7aD");
+var MARINADE_STATE_SIZE = 520;
+var MSOL_PRICE_OFFSET = 512;
+var MSOL_PRICE_PRECISION = new BigNumber3__default.default(2).pow(32);
+function decodeMarinadeState(data) {
+  if (data.length !== MARINADE_STATE_SIZE) {
+    throw new Error(`Invalid Marinade State account size: ${data.length}`);
+  }
+  const msolPriceRaw = data.readBigUInt64LE(MSOL_PRICE_OFFSET);
+  return {
+    msolPrice: new BigNumber3__default.default(msolPriceRaw.toString()).div(MSOL_PRICE_PRECISION)
+  };
+}
+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;
+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");
+  }
+  return {
+    totalLamports,
+    poolTokenSupply,
+    lastUpdateEpoch,
+    exchangeRate: new BigNumber3__default.default(totalLamports.toString()).div(
+      new BigNumber3__default.default(poolTokenSupply.toString())
+    )
+  };
+}
 var GAMMA_VAULT_PROGRAM_ID = new web3_js.PublicKey(
   "GaMmanX9i4jGmqDZZD2tbD6B2v9p21btenPneMXnTczV"
 );
@@ -80577,16 +80921,17 @@ function chunkArray(array4, chunkSize) {
 }
 
 // src/services/price/services/pyth-oracle.service.ts
-var fetchPythOracleData = async (banks, opts) => {
+var fetchPythOracleData = async (banks, opts, priceCoeffByBank = {}) => {
   const {
     pythPushBanks,
     pythStakedCollateralBanks,
     pythPushKaminosBanks,
     driftPythPullBanks,
     solendPythPullBanks,
-    juplendPythPullBanks
+    juplendPythPullBanks,
+    pythMultipliedBanks
   } = categorizePythBanks(banks);
-  if (!pythPushBanks.length && !pythStakedCollateralBanks.length && !pythPushKaminosBanks.length && !driftPythPullBanks.length && !solendPythPullBanks.length && !juplendPythPullBanks.length) {
+  if (!pythPushBanks.length && !pythStakedCollateralBanks.length && !pythPushKaminosBanks.length && !driftPythPullBanks.length && !solendPythPullBanks.length && !juplendPythPullBanks.length && !pythMultipliedBanks.length) {
     return {
       bankOraclePriceMap: /* @__PURE__ */ new Map()
     };
@@ -80597,9 +80942,9 @@ var fetchPythOracleData = async (banks, opts) => {
     ...pythPushKaminosBanks,
     ...driftPythPullBanks,
     ...solendPythPullBanks,
-    ...juplendPythPullBanks
+    ...juplendPythPullBanks,
+    ...pythMultipliedBanks
   ];
-  const priceCoeffByBank = {};
   const pythOracleKeys = extractPythOracleKeys(combinedPythBanks);
   const uniquePythOracleKeys = Array.from(new Set(pythOracleKeys));
   let oraclePrices;
@@ -80614,10 +80959,15 @@ var fetchPythOracleData = async (banks, opts) => {
   }
   const bankOraclePriceMap = mapPythBanksToOraclePrices(
     combinedPythBanks,
-    pythStakedCollateralBanks,
+    [...pythStakedCollateralBanks, ...pythMultipliedBanks],
     oraclePrices,
     priceCoeffByBank
   );
+  pythMultipliedBanks.forEach((bank) => {
+    if (priceCoeffByBank[bank.address.toBase58()] === void 0) {
+      bankOraclePriceMap.delete(bank.address.toBase58());
+    }
+  });
   return {
     bankOraclePriceMap
   };
@@ -80889,16 +81239,242 @@ async function fetchSingleCrossbarChunk(endpoint, swbFeedIdsChunk, isPrimary) {
     throw error;
   }
 }
+var scopeRequestKey = (bank) => `${bank.config.oracleKeys[0].toBase58()}:${bank.config.scopeEntryIndex}`;
+var fetchScopeOracleData = async (banks, opts) => {
+  const scopeBanks = banks.filter((bank) => getOracleSourceFromBank(bank).key === "scope");
+  if (!scopeBanks.length) {
+    return {
+      bankOraclePriceMap: /* @__PURE__ */ new Map()
+    };
+  }
+  const uniqueRequestKeys = Array.from(new Set(scopeBanks.map(scopeRequestKey)));
+  let oraclePrices;
+  if (opts.mode === "api") {
+    oraclePrices = await fetchScopeOraclePricesFromAPI(
+      uniqueRequestKeys,
+      opts.scopeOnchainData.endpoint,
+      { queryKey: opts.scopeOnchainData.queryKey }
+    );
+  } else {
+    oraclePrices = await fetchScopeOraclePricesFromChain(uniqueRequestKeys, opts.connection);
+  }
+  const bankOraclePriceMap = /* @__PURE__ */ new Map();
+  const nowSeconds = Math.floor(Date.now() / 1e3);
+  scopeBanks.forEach((bank) => {
+    let oraclePrice = oraclePrices[scopeRequestKey(bank)];
+    const isStale = !oraclePrice || nowSeconds - oraclePrice.timestamp.toNumber() > bank.config.oracleMaxAge;
+    if (isStale) {
+      oraclePrice = {
+        priceRealtime: {
+          price: new BigNumber3__default.default(0),
+          confidence: new BigNumber3__default.default(0),
+          lowestPrice: new BigNumber3__default.default(0),
+          highestPrice: new BigNumber3__default.default(0)
+        },
+        priceWeighted: {
+          price: new BigNumber3__default.default(0),
+          confidence: new BigNumber3__default.default(0),
+          lowestPrice: new BigNumber3__default.default(0),
+          highestPrice: new BigNumber3__default.default(0)
+        },
+        timestamp: oraclePrice?.timestamp ?? new BigNumber3__default.default(0)
+      };
+    }
+    bankOraclePriceMap.set(bank.address.toBase58(), oraclePrice);
+  });
+  return {
+    bankOraclePriceMap
+  };
+};
+var fetchScopeOraclePricesFromAPI = async (requestKeys, apiEndpoint, opts) => {
+  const queryKey = opts?.queryKey ?? "scopeKeys";
+  const response = await fetch(`${apiEndpoint}?${queryKey}=${requestKeys.join(",")}`);
+  if (!response.ok) {
+    throw new Error("Failed to fetch scope oracle data");
+  }
+  const { data } = await response.json();
+  return Object.fromEntries(
+    Object.entries(data).map(([key, oraclePrice]) => [
+      key,
+      {
+        priceRealtime: {
+          price: BigNumber3__default.default(oraclePrice.priceRealtime.price),
+          confidence: BigNumber3__default.default(oraclePrice.priceRealtime.confidence),
+          lowestPrice: BigNumber3__default.default(oraclePrice.priceRealtime.lowestPrice),
+          highestPrice: BigNumber3__default.default(oraclePrice.priceRealtime.highestPrice)
+        },
+        priceWeighted: {
+          price: BigNumber3__default.default(oraclePrice.priceWeighted.price),
+          confidence: BigNumber3__default.default(oraclePrice.priceWeighted.confidence),
+          lowestPrice: BigNumber3__default.default(oraclePrice.priceWeighted.lowestPrice),
+          highestPrice: BigNumber3__default.default(oraclePrice.priceWeighted.highestPrice)
+        },
+        timestamp: BigNumber3__default.default(oraclePrice.timestamp)
+      }
+    ])
+  );
+};
+var fetchScopeOraclePricesFromChain = async (requestKeys, connection) => {
+  const uniqueOracleKeys = Array.from(new Set(requestKeys.map((key) => key.split(":")[0])));
+  const oracleAis = await chunkedGetRawMultipleAccountInfoOrdered(connection, uniqueOracleKeys);
+  const accountDataByKey = {};
+  uniqueOracleKeys.forEach((oracleKey, index) => {
+    accountDataByKey[oracleKey] = oracleAis[index]?.data;
+  });
+  const oraclePriceByRequestKey = {};
+  for (const requestKey of requestKeys) {
+    const [oracleKey, entryIndexRaw] = requestKey.split(":");
+    const data = accountDataByKey[oracleKey];
+    let price = new BigNumber3__default.default(0);
+    let timestamp = new BigNumber3__default.default(0);
+    if (data) {
+      try {
+        const entry = decodeScopePriceAtIndex(data, Number(entryIndexRaw));
+        price = entry.price;
+        timestamp = new BigNumber3__default.default(entry.unixTimestamp);
+      } catch (e) {
+        console.error(`Failed to decode scope entry ${requestKey}`, e);
+      }
+    }
+    oraclePriceByRequestKey[requestKey] = {
+      priceRealtime: {
+        price,
+        confidence: new BigNumber3__default.default(0),
+        lowestPrice: price,
+        highestPrice: price
+      },
+      priceWeighted: {
+        price,
+        confidence: new BigNumber3__default.default(0),
+        lowestPrice: price,
+        highestPrice: price
+      },
+      timestamp
+    };
+  }
+  return oraclePriceByRequestKey;
+};
+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;
+  let expectedRate;
+  if (vault.duration <= 0 || 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));
+  }
+  if (vault.ptSupply === 0n) {
+    throw new Error("Exponent vault has zero PT supply");
+  }
+  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);
+}
+var fetchOracleMultipliers = async (banks, opts) => {
+  const multipliedBanks = banks.filter((bank) => multiplierAccountKey(bank) !== void 0);
+  if (!multipliedBanks.length) {
+    return {};
+  }
+  if (opts.mode === "api") {
+    return fetchOracleMultipliersFromAPI(
+      multipliedBanks.map((bank) => bank.address.toBase58()),
+      opts.multiplierData.endpoint,
+      { queryKey: opts.multiplierData.queryKey }
+    );
+  }
+  return fetchOracleMultipliersFromChain(multipliedBanks, opts.connection);
+};
+var fetchOracleMultipliersFromAPI = async (bankAddresses, apiEndpoint, opts) => {
+  const queryKey = opts?.queryKey ?? "bankAddresses";
+  const response = await fetch(`${apiEndpoint}?${queryKey}=${bankAddresses.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)])
+  );
+};
+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 chunkedGetRawMultipleAccountInfoOrdered(connection, uniqueAccountKeys);
+  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)];
+    if (!data) {
+      console.error(`Missing multiplier account for bank ${bankAddress}`);
+      continue;
+    }
+    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 */:
+          multiplierByBank[bankAddress] = decodeStakePool(data).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);
+    }
+  }
+  return multiplierByBank;
+};
 var fetchOracleData = async (banks, opts) => {
   const { zeroOracleBanks, isolatedAssetBanks, collateralAssetBanks, fixedAssetBanks } = classifyBanksForOracleStrategy(banks);
   const zeroResults = handleZeroOracleBanks(zeroOracleBanks);
   const fetchIsolatedPrice = opts?.isolatedBanksOpts?.fetchPrices ?? false;
   const isolatedResults = fetchIsolatedPrice ? handleIsolatedAssetBanks(isolatedAssetBanks, opts?.isolatedBanksOpts?.staticPricesByBank) : /* @__PURE__ */ new Map();
-  const fixedResults = handleFixedOracleBanks(fixedAssetBanks);
+  const multiplierByBank = await fetchOracleMultipliers(banks, opts.oracleMultiplierOpts);
+  const fixedResults = handleFixedOracleBanks(fixedAssetBanks, multiplierByBank);
   const assetBanks = [...collateralAssetBanks, ...fetchIsolatedPrice ? isolatedAssetBanks : []];
   const assetResults = await handleAssetBanks(assetBanks, {
     pythOpts: opts.pythOpts,
-    swbOpts: opts.swbOpts
+    swbOpts: opts.swbOpts,
+    scopeOpts: opts.scopeOpts,
+    priceCoeffByBank: multiplierByBank
   });
   return mergeOracleResults([zeroResults, isolatedResults, assetResults, fixedResults], banks);
 };
@@ -80932,10 +81508,11 @@ function classifyBanksForOracleStrategy(banks) {
     fixedAssetBanks
   };
 }
-function handleFixedOracleBanks(banks) {
+function handleFixedOracleBanks(banks, multiplierByBank) {
   const oracleMap = /* @__PURE__ */ new Map();
   banks.forEach((bank) => {
-    const fixedPrice = bank.config.fixedPrice;
+    const multiplier = multiplierByBank[bank.address.toBase58()];
+    const fixedPrice = bank.config.oracleSetup === "PTFixed" /* PTFixed */ && multiplier !== void 0 ? BigNumber3__default.default(multiplier) : bank.config.fixedPrice;
     const fixedOraclePrice = {
       priceRealtime: {
         price: fixedPrice,
@@ -81004,9 +81581,10 @@ async function handleAssetBanks(banks, opts) {
   if (banks.length === 0) {
     return /* @__PURE__ */ new Map();
   }
-  const [pythData, swbData] = await Promise.all([
-    fetchPythOracleData(banks, opts.pythOpts),
-    fetchSwbOracleData(banks, opts.swbOpts)
+  const [pythData, swbData, scopeData] = await Promise.all([
+    fetchPythOracleData(banks, opts.pythOpts, opts.priceCoeffByBank),
+    fetchSwbOracleData(banks, opts.swbOpts),
+    fetchScopeOracleData(banks, opts.scopeOpts)
   ]);
   const bankOraclePriceMap = /* @__PURE__ */ new Map();
   pythData.bankOraclePriceMap.forEach((oraclePrice, bankAddress) => {
@@ -81015,6 +81593,9 @@ async function handleAssetBanks(banks, opts) {
   swbData.bankOraclePriceMap.forEach((oraclePrice, bankAddress) => {
     bankOraclePriceMap.set(bankAddress, oraclePrice);
   });
+  scopeData.bankOraclePriceMap.forEach((oraclePrice, bankAddress) => {
+    bankOraclePriceMap.set(bankAddress, oraclePrice);
+  });
   banks.forEach((bank) => {
     const bankAddress = bank.address.toBase58();
     const oraclePrice = bankOraclePriceMap.get(bankAddress);
@@ -83397,7 +83978,8 @@ var Bank = class _Bank {
       bankType.config.operationalState,
       bankType.config.oracleMaxConfidence,
       bankType.config.fixedPrice,
-      bankType.config.configFlags
+      bankType.config.configFlags,
+      bankType.config.scopeEntryIndex
     );
     return new _Bank(
       bankType.address,
@@ -83566,7 +84148,7 @@ var Bank = class _Bank {
   }
 };
 var BankConfig = class _BankConfig {
-  constructor(assetWeightInit, assetWeightMaint, liabilityWeightInit, liabilityWeightMaint, depositLimit, borrowLimit, riskTier, totalAssetValueInitLimit, assetTag, oracleSetup, oracleKeys, oracleMaxAge, interestRateConfig, operationalState, oracleMaxConfidence, fixedPrice, configFlags) {
+  constructor(assetWeightInit, assetWeightMaint, liabilityWeightInit, liabilityWeightMaint, depositLimit, borrowLimit, riskTier, totalAssetValueInitLimit, assetTag, oracleSetup, oracleKeys, oracleMaxAge, interestRateConfig, operationalState, oracleMaxConfidence, fixedPrice, configFlags, scopeEntryIndex = 0) {
     this.assetWeightInit = assetWeightInit;
     this.assetWeightMaint = assetWeightMaint;
     this.liabilityWeightInit = liabilityWeightInit;
@@ -83584,6 +84166,7 @@ var BankConfig = class _BankConfig {
     this.oracleMaxConfidence = oracleMaxConfidence;
     this.fixedPrice = fixedPrice;
     this.configFlags = configFlags;
+    this.scopeEntryIndex = scopeEntryIndex;
   }
   static fromAccountParsed(bankConfigRaw) {
     const bankConfig = parseBankConfigRaw(bankConfigRaw);
@@ -83604,7 +84187,8 @@ var BankConfig = class _BankConfig {
       bankConfig.operationalState,
       bankConfig.oracleMaxConfidence,
       bankConfig.fixedPrice,
-      bankConfig.configFlags
+      bankConfig.configFlags,
+      bankConfig.scopeEntryIndex
     );
   }
 };
@@ -84783,6 +85367,14 @@ var Project0Client = class _Project0Client {
         mode: "on-chain",
         connection
       },
+      scopeOpts: {
+        mode: "on-chain",
+        connection
+      },
+      oracleMultiplierOpts: {
+        mode: "on-chain",
+        connection
+      },
       isolatedBanksOpts: {
         fetchPrices: true
       }
@@ -85054,6 +85646,7 @@ exports.computeBankMetrics = computeBankMetrics;
 exports.computeBankPoolSize = computeBankPoolSize;
 exports.computeBankProjectedAvailableLiquidity = computeBankProjectedAvailableLiquidity;
 exports.computeBankRateLimitRemaining = computeBankRateLimitRemaining;
+exports.computeBankRiskAccountKeys = computeBankRiskAccountKeys;
 exports.computeBankSupplyApy = computeBankSupplyApy;
 exports.computeBankTotalBorrows = computeBankTotalBorrows;
 exports.computeBankTotalBorrowsUsd = computeBankTotalBorrowsUsd;
@@ -85087,6 +85680,7 @@ exports.computeMaxWithdrawForBank = computeMaxWithdrawForBank;
 exports.computeNetApy = computeNetApy;
 exports.computeProjectedActiveBalancesNoCpi = computeProjectedActiveBalancesNoCpi;
 exports.computeProjectedActiveBanksNoCpi = computeProjectedActiveBanksNoCpi;
+exports.computePtMultiplier = computePtMultiplier;
 exports.computeQuantity = computeQuantity;
 exports.computeQuantityUi = computeQuantityUi;
 exports.computeRateLimitWindowRemainingCapacity = computeRateLimitWindowRemainingCapacity;
@@ -85151,10 +85745,16 @@ exports.fetchMarginfiAccountData = fetchMarginfiAccountData;
 exports.fetchMultipleBanks = fetchMultipleBanks;
 exports.fetchNativeStakeAccounts = fetchNativeStakeAccounts;
 exports.fetchOracleData = fetchOracleData;
+exports.fetchOracleMultipliers = fetchOracleMultipliers;
+exports.fetchOracleMultipliersFromAPI = fetchOracleMultipliersFromAPI;
+exports.fetchOracleMultipliersFromChain = fetchOracleMultipliersFromChain;
 exports.fetchProgramForMints = fetchProgramForMints;
 exports.fetchPythOracleData = fetchPythOracleData;
 exports.fetchPythOraclePricesFromAPI = fetchPythOraclePricesFromAPI;
 exports.fetchPythOraclePricesFromChain = fetchPythOraclePricesFromChain;
+exports.fetchScopeOracleData = fetchScopeOracleData;
+exports.fetchScopeOraclePricesFromAPI = fetchScopeOraclePricesFromAPI;
+exports.fetchScopeOraclePricesFromChain = fetchScopeOraclePricesFromChain;
 exports.fetchStakeAccount = fetchStakeAccount;
 exports.fetchStakePoolActiveStates = fetchStakePoolActiveStates;
 exports.fetchStakePoolMev = fetchStakePoolMev;