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

package/dist/index.js

@@ -13237,6 +13237,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: [
@@ -14326,13 +14346,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",
@@ -19283,6 +19303,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"
           }
         ]
       }
@@ -20703,6 +20861,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) => {
@@ -21764,8 +21932,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) {
@@ -21806,6 +21992,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}"`);
   }
@@ -21919,7 +22123,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) {
@@ -22025,7 +22230,8 @@ function bankConfigToBankConfigRaw(config) {
     totalAssetValueInitLimit: new BN9(config.totalAssetValueInitLimit.toString()),
     oracleMaxAge: config.oracleMaxAge,
     oracleMaxConfidence: config.oracleMaxConfidence,
-    fixedPrice: bigNumberToWrappedI80F48(config.fixedPrice)
+    fixedPrice: bigNumberToWrappedI80F48(config.fixedPrice),
+    scopeEntryIndex: config.scopeEntryIndex
   };
 }
 function bankConfigRawToDto(bankConfigRaw) {
@@ -22046,7 +22252,8 @@ function bankConfigRawToDto(bankConfigRaw) {
     interestRateConfig: bankConfigRaw.interestRateConfig,
     configFlags: bankConfigRaw.configFlags,
     oracleMaxConfidence: bankConfigRaw.oracleMaxConfidence,
-    fixedPrice: bankConfigRaw.fixedPrice
+    fixedPrice: bankConfigRaw.fixedPrice,
+    scopeEntryIndex: bankConfigRaw.scopeEntryIndex
   };
 }
 
@@ -22334,7 +22541,8 @@ function dtoToBankConfig(bankConfigDto) {
     oracleMaxAge: bankConfigDto.oracleMaxAge,
     interestRateConfig: dtoToInterestRateConfig(bankConfigDto.interestRateConfig),
     oracleMaxConfidence: bankConfigDto.oracleMaxConfidence,
-    fixedPrice: new BigNumber3(bankConfigDto.fixedPrice)
+    fixedPrice: new BigNumber3(bankConfigDto.fixedPrice),
+    scopeEntryIndex: bankConfigDto.scopeEntryIndex ?? 0
   };
 }
 function dtoToInterestRateConfig(interestRateConfigDto) {
@@ -22447,7 +22655,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) {
@@ -22464,7 +22673,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
@@ -22487,6 +22696,7 @@ function parseBankConfigRaw(bankConfigRaw) {
   };
   const oracleMaxConfidence = bankConfigRaw.oracleMaxConfidence;
   const fixedPrice = wrappedI80F48toBigNumber(bankConfigRaw.fixedPrice);
+  const scopeEntryIndex = bankConfigRaw.scopeEntryIndex ?? 0;
   return {
     assetWeightInit,
     assetWeightMaint,
@@ -22504,7 +22714,8 @@ function parseBankConfigRaw(bankConfigRaw) {
     oracleMaxAge,
     interestRateConfig,
     oracleMaxConfidence,
-    fixedPrice
+    fixedPrice,
+    scopeEntryIndex
   };
 }
 function parseRiskTier(riskTierRaw) {
@@ -22566,18 +22777,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) {
@@ -25708,6 +25937,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,
@@ -25715,7 +25955,8 @@ var categorizePythBanks = (banks) => {
     pythPushKaminosBanks,
     driftPythPullBanks,
     solendPythPullBanks,
-    juplendPythPullBanks
+    juplendPythPullBanks,
+    pythMultipliedBanks
   };
 };
 var convertVoteAccCoeffsToBankCoeffs = (pythStakedCollateralBanks, validatorVoteAccountByBank, voteAccCoeffs) => {
@@ -25732,7 +25973,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();
@@ -25741,7 +25982,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) {
@@ -25759,7 +26000,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)
 });
@@ -25811,6 +26052,7 @@ var ORACLE_SOURCES = {
   switchboard: "Switchboard",
   pyth: "Pyth",
   fixed: "Fixed",
+  scope: "Scope",
   unknown: "Unknown"
 };
 function getOracleSourceNameFromKey(oracleSourceKey) {
@@ -25837,14 +26079,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;
@@ -27319,6 +27572,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];
@@ -72073,7 +72339,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) {
@@ -74942,6 +75210,82 @@ function makeRefreshIntegrationBanksIxs(marginfiAccount, bankMap, banksToExclude
     keys: [...kaminoRefreshIxs.keys, ...updateDriftMarketIxs.keys, ...updateJupLendRateIxs.keys]
   };
 }
+new 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(value.toString()).shiftedBy(-Number(exp));
+  return {
+    price,
+    lastUpdatedSlot: Number(lastUpdatedSlot),
+    unixTimestamp: Number(unixTimestamp)
+  };
+}
+new PublicKey("MarBmsSgKXdrN1egZf5sqe1TMai9K1rChYNDJgjq7aD");
+var MARINADE_STATE_SIZE = 520;
+var MSOL_PRICE_OFFSET = 512;
+var MSOL_PRICE_PRECISION = new BigNumber3(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(msolPriceRaw.toString()).div(MSOL_PRICE_PRECISION)
+  };
+}
+new PublicKey(
+  "SPoo1Ku8WFXoNDMHPsrGSTSG1Y47rzgn41SLUNakuHy"
+);
+new PublicKey(
+  "SP12tWFxD9oJsVWNavTTBZvMbA6gkAmxtVgxdqvyvhY"
+);
+new 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(totalLamports.toString()).div(
+      new BigNumber3(poolTokenSupply.toString())
+    )
+  };
+}
 var GAMMA_VAULT_PROGRAM_ID = new PublicKey(
   "GaMmanX9i4jGmqDZZD2tbD6B2v9p21btenPneMXnTczV"
 );
@@ -80549,16 +80893,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()
     };
@@ -80569,9 +80914,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;
@@ -80586,10 +80931,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
   };
@@ -80861,16 +81211,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(0),
+          confidence: new BigNumber3(0),
+          lowestPrice: new BigNumber3(0),
+          highestPrice: new BigNumber3(0)
+        },
+        priceWeighted: {
+          price: new BigNumber3(0),
+          confidence: new BigNumber3(0),
+          lowestPrice: new BigNumber3(0),
+          highestPrice: new BigNumber3(0)
+        },
+        timestamp: oraclePrice?.timestamp ?? new BigNumber3(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(oraclePrice.priceRealtime.price),
+          confidence: BigNumber3(oraclePrice.priceRealtime.confidence),
+          lowestPrice: BigNumber3(oraclePrice.priceRealtime.lowestPrice),
+          highestPrice: BigNumber3(oraclePrice.priceRealtime.highestPrice)
+        },
+        priceWeighted: {
+          price: BigNumber3(oraclePrice.priceWeighted.price),
+          confidence: BigNumber3(oraclePrice.priceWeighted.confidence),
+          lowestPrice: BigNumber3(oraclePrice.priceWeighted.lowestPrice),
+          highestPrice: BigNumber3(oraclePrice.priceWeighted.highestPrice)
+        },
+        timestamp: BigNumber3(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(0);
+    let timestamp = new BigNumber3(0);
+    if (data) {
+      try {
+        const entry = decodeScopePriceAtIndex(data, Number(entryIndexRaw));
+        price = entry.price;
+        timestamp = new BigNumber3(entry.unixTimestamp);
+      } catch (e) {
+        console.error(`Failed to decode scope entry ${requestKey}`, e);
+      }
+    }
+    oraclePriceByRequestKey[requestKey] = {
+      priceRealtime: {
+        price,
+        confidence: new BigNumber3(0),
+        lowestPrice: price,
+        highestPrice: price
+      },
+      priceWeighted: {
+        price,
+        confidence: new BigNumber3(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(1);
+  } else {
+    const progress = new BigNumber3(nowSeconds - vault.startTs).div(vault.duration);
+    expectedRate = startPrice.plus(new BigNumber3(1).minus(startPrice).times(progress));
+  }
+  if (vault.ptSupply === 0n) {
+    throw new Error("Exponent vault has zero PT supply");
+  }
+  const syPerPt = new BigNumber3(vault.syForPt.toString()).div(
+    new BigNumber3(vault.ptSupply.toString())
+  );
+  const redemptionCap = syPerPt.times(vault.lastSeenSyExchangeRate);
+  return BigNumber3.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);
 };
@@ -80904,10 +81480,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(multiplier) : bank.config.fixedPrice;
     const fixedOraclePrice = {
       priceRealtime: {
         price: fixedPrice,
@@ -80976,9 +81553,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) => {
@@ -80987,6 +81565,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);
@@ -83369,7 +83950,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,
@@ -83538,7 +84120,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;
@@ -83556,6 +84138,7 @@ var BankConfig = class _BankConfig {
     this.oracleMaxConfidence = oracleMaxConfidence;
     this.fixedPrice = fixedPrice;
     this.configFlags = configFlags;
+    this.scopeEntryIndex = scopeEntryIndex;
   }
   static fromAccountParsed(bankConfigRaw) {
     const bankConfig = parseBankConfigRaw(bankConfigRaw);
@@ -83576,7 +84159,8 @@ var BankConfig = class _BankConfig {
       bankConfig.operationalState,
       bankConfig.oracleMaxConfidence,
       bankConfig.fixedPrice,
-      bankConfig.configFlags
+      bankConfig.configFlags,
+      bankConfig.scopeEntryIndex
     );
   }
 };
@@ -84755,6 +85339,14 @@ var Project0Client = class _Project0Client {
         mode: "on-chain",
         connection
       },
+      scopeOpts: {
+        mode: "on-chain",
+        connection
+      },
+      oracleMultiplierOpts: {
+        mode: "on-chain",
+        connection
+      },
       isolatedBanksOpts: {
         fetchPrices: true
       }
@@ -84887,6 +85479,6 @@ var EmodeSettings = class _EmodeSettings {
   }
 };
 
-export { ADDRESS_LOOKUP_TABLE_FOR_GROUP, ADDRESS_LOOKUP_TABLE_FOR_GROUP_NATIVE_STAKE, ADDRESS_LOOKUP_TABLE_FOR_SWAP, AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_BRIDGE_MINTS, DEFAULT_CROSSBAR_URL, DEFAULT_FALLBACK_CROSSBAR_URL, DEFAULT_ORACLE_MAX_AGE, DEFAULT_REPAY_ALL_EXTRA_BUFFER_BPS, DISABLED_FLAG, EMPTY_HEALTH_CACHE, EXECUTION_HEADROOM_SECONDS, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, HealthCacheStatus, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, LST_MINT, MARGINFI_IDL, MARGINFI_PROGRAM, MARGINFI_PROGRAM_STAGING, MARGINFI_PROGRAM_STAGING_ALT, MARGINFI_SPONSORED_SHARD_ID, MAX_ACCOUNT_LOCKS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, MarginRequirementType, MarginfiAccount, MarginfiAccountWrapper, MarginfiGroup, OperationalState, OracleSetup, PDA_BANK_EMISSIONS_AUTH_SEED, PDA_BANK_EMISSIONS_VAULT_SEED, PDA_BANK_FEE_STATE_SEED, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PDA_MARGINFI_ACCOUNT_SEED, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, Project0Client, RiskTier, SECONDS_PER_YEAR, SINGLE_POOL_PROGRAM_ID, STAKED_ORACLE_DISABLED_FLAG, STAKED_ORACLE_USES_ONRAMP_FLAG, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWAP_ADAPTERS, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, SwapProvider, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionBuildingError, TransactionBuildingErrorCode, TransactionConfigMap, TransactionType, U64_MAX, USDC_DECIMALS, USDC_MINT, USDT_MINT, VENUE_AVAILABLE_LIQUIDITY_BUFFER, WSOL_MINT, ZERO_ORACLE_KEY, accountConflictsWithBridgeBank, accountFlagToBN, addOracleToBanksIx, addTransactionMetadata, adjustPriceComponent, aprToApy, apyToApr, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankMetadataMapToDto, bankMetadataToDto, bankRateLimiterRawToDto, bankRawToDto, bigNumberToWrappedI80F48, bpsToPercentile, buildCollateralLegIxs, calculateApyFromInterest, calculateInterestFromApy, capConfidenceInterval, categorizePythBanks, checkBatchOracleCrankability, checkJupiterFeeAccount, checkMultipleOraclesCrankability, checkTitanFeeAccount, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, classifyAndValidate, compileFlashloanPrecheck, composeBridgedSwap, composeRemainingAccounts, computeAccountValue, computeAccrualProjectionSeconds, computeActiveEmodePairs, computeAssetHealthComponent, computeAssetUsdValue, computeBalanceUsdValue, computeBankAvailableLiquidity, computeBankBorrowApy, computeBankBorrowCapRemaining, computeBankDepositCapRemaining, computeBankMetrics, computeBankPoolSize, computeBankProjectedAvailableLiquidity, computeBankRateLimitRemaining, computeBankSupplyApy, computeBankTotalBorrows, computeBankTotalBorrowsUsd, computeBankTotalDeposits, computeBankTotalDepositsUsd, computeBaseInterestRate, computeBorrowEstimateForRepay, computeClaimedEmissions, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeGroupRateLimitRemainingUsd, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeInterestRates, computeLiabilityHealthComponent, computeLiabilityUsdValue, computeLiquidationPriceForBank, computeLoopingParams, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxDepositForBank, computeMaxLeverage, computeMaxWithdrawForBank, computeNetApy, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computeQuantity, computeQuantityUi, computeRateLimitWindowRemainingCapacity, computeRateLimiterRemainingCapacity, computeRemainingCapacity, computeSmartCrank, computeStakedBankMultipliers, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, computeV0TxSize, computeVenueAvailableLiquidity, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, deserializeInstruction, deserializeLut, deserializeSwapEngineRequest, deserializeSwapEngineResult, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRateLimiter, dtoToBankRateLimiterRaw, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchGammaLpVault, fetchGammaWithdrawReceipt, fetchMarginfiAccountActiveBalancesForBank, fetchMarginfiAccountAddresses, fetchMarginfiAccountAddressesHoldingBank, fetchMarginfiAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleAccountsFromAPI, fetchSwbOracleAccountsFromChain, fetchSwbOracleData, fetchSwbOraclePricesFromAPI, fetchSwbOraclePricesFromCrossbar, findRandomAvailableAccountIndex, freezeBankConfigIx, generateDummyAccount, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, getAssetWeight, getBalance, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getBirdeyeFallbackPricesByFeedId, getBirdeyePricesForMints, getConfig, getDriftCTokenMultiplier, getDriftMetadata, getDriftStatesDto, getEffectiveDepositLimit, getEmodePairs, getExactOutEstimate, getFallbackPricesByFeedId, getFallbackPricesForMints, getHealthCacheStatusDescription, getHealthSimulationTransactions, getJupLendFTokenMultiplier, getJupLendMetadata, getJupLendStatesDto, getJupiterReferralFeeAccount, getJupiterSwapIxsForFlashloan, getKaminoCTokenMultiplier, getKaminoMetadata, getKaminoStatesDto, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getOracleSourceFromBank, getOracleSourceFromOracleSetup, getOracleSourceNameFromKey, getPrice, getPriceWithConfidence, getStakedBankMetadataMap, getSwapAdapter, getSwapIxsForFlashloan, getTitanExactOutEstimate, getTitanSwapIxsForFlashloan, getTotalAccountKeys, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, getValidatorVoteAccountByBank, getWritableAccountKeys, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, isBorrowLimitActive, isBridgeConflictError, isDecomposableSwapError, isDepositIx, isDepositLimitActive, isFlashloan, isGroupRateLimiterEnabled, isStandardBorrowable, isStandardDepositable, isV0Tx, isWeightedPrice, isWholePosition, makeAccountTransferToNewAccountTx, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx3 as makeBeginFlashLoanIx, makeBorrowIx3 as makeBorrowIx, makeBorrowTx, makeBridgedLoopTx, makeBridgedSwapCollateralTx, makeBridgedSwapDebtTx, makeBulkRepayTx, makeBulkWithdrawTx, makeBundleTipIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCrankSwbFeedIx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx3 as makeDepositIx, makeDepositTx, makeDriftDepositIx3 as makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx3 as makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx3 as makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx2 as makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx2 as makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx3 as makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx3 as makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx2 as makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshIntegrationBanksIxs, makeRefreshKaminoBanksIxs, makeRepayIx3 as makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeRollPtTx, makeSetupIx, makeSmartCrankSwbFeedIx, makeSmartCrankSwbFeedIxForAccounts, makeSwapCollateralTx, makeSwapDebtTx, makeTransferPositionsTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVaultCompleteWithdrawalIx, makeVaultCompleteWithdrawalTx, makeVaultDepositIx, makeVaultDepositTx, makeVaultDepositWithSwapTx, makeVaultWithdrawIx, makeVaultWithdrawTx, makeVersionedTransaction, makeWithdrawIx3 as makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapBrokenFeedsToOraclePrices, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, mapSwbBanksToOraclePrices, marginfiAccountToDto, mergeBridgeQuotes, mergeBridgeQuotesDebt, mergeBridgeQuotesLoop, nativeToUi, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRateLimiterRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, parseSwbOraclePriceData, partitionBanksByCrankability, patchDepositAmount, requireBank, requireTokenProgram, resolveAmount, resolveBridgeCandidateBanks, resolvePinnedSwapRoute, resolveTokenProgramForMint, resolveVaultTokenProgram, runSwapEngine, selectLutsForAccountAction, selectLutsForBanks, selectSwapBridges, serializeBankConfigOpt, serializeInstruction, serializeInterestRateConfig, serializeLut, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, serializeSwapEngineRequest, serializeSwapEngineResult, sharedBridgeLegContext, shortenAddress, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateBundle, splitInstructionsToFitTransactions, swapEngineProvidersFromOpts, swapEngineQuoteFieldsFromOpts, toBankConfigDto, toBankDto, toBankRateLimiterDto, toBigNumber, toEmodeSettingsDto, toInterestRateConfigDto, toJupiterConfig, toNumber, tryBridgeCandidates, uiToNative, uiToNativeBigNumber, validatorStakeGroupToDto, wrappedI80F48toBigNumber };
+export { ADDRESS_LOOKUP_TABLE_FOR_GROUP, ADDRESS_LOOKUP_TABLE_FOR_GROUP_NATIVE_STAKE, ADDRESS_LOOKUP_TABLE_FOR_SWAP, AccountFlags, AccountType, AssetTag, BUNDLE_TX_SIZE, Balance, Bank, BankConfig, BankConfigFlag, BankVaultType, DEFAULT_BRIDGE_MINTS, DEFAULT_CROSSBAR_URL, DEFAULT_FALLBACK_CROSSBAR_URL, DEFAULT_ORACLE_MAX_AGE, DEFAULT_REPAY_ALL_EXTRA_BUFFER_BPS, DISABLED_FLAG, EMPTY_HEALTH_CACHE, EXECUTION_HEADROOM_SECONDS, EmodeEntryFlags, EmodeFlags, EmodeImpactStatus, EmodeSettings, EmodeTag, FLASHLOAN_ENABLED_FLAG, HOURS_PER_YEAR, HealthCache, HealthCacheFlags, HealthCacheSimulationError, HealthCacheStatus, JUPITER_V6_PROGRAM, JUP_SWAP_LUT_PROGRAM_AUTHORITY_INDEX, LST_MINT, MARGINFI_IDL, MARGINFI_PROGRAM, MARGINFI_PROGRAM_STAGING, MARGINFI_PROGRAM_STAGING_ALT, MARGINFI_SPONSORED_SHARD_ID, MAX_ACCOUNT_LOCKS, MAX_CONFIDENCE_INTERVAL_RATIO, MAX_TX_SIZE, MAX_U64, MPL_METADATA_PROGRAM_ID, MarginRequirementType, MarginfiAccount, MarginfiAccountWrapper, MarginfiGroup, OperationalState, OracleSetup, PDA_BANK_EMISSIONS_AUTH_SEED, PDA_BANK_EMISSIONS_VAULT_SEED, PDA_BANK_FEE_STATE_SEED, PDA_BANK_FEE_VAULT_AUTH_SEED, PDA_BANK_FEE_VAULT_SEED, PDA_BANK_INSURANCE_VAULT_AUTH_SEED, PDA_BANK_INSURANCE_VAULT_SEED, PDA_BANK_LIQUIDITY_VAULT_AUTH_SEED, PDA_BANK_LIQUIDITY_VAULT_SEED, PDA_MARGINFI_ACCOUNT_SEED, PRIORITY_TX_SIZE, PYTH_PRICE_CONF_INTERVALS, PYTH_PUSH_ORACLE_ID, PYTH_SPONSORED_SHARD_ID, PriceBias, Project0Client, RiskTier, SECONDS_PER_YEAR, SINGLE_POOL_PROGRAM_ID, STAKED_ORACLE_DISABLED_FLAG, STAKED_ORACLE_USES_ONRAMP_FLAG, STAKE_CONFIG_ID, STAKE_PROGRAM_ID, SWAP_ADAPTERS, SWB_PRICE_CONF_INTERVALS, SYSTEM_PROGRAM_ID, SYSVAR_CLOCK_ID, SYSVAR_RENT_ID, SYSVAR_STAKE_HISTORY_ID, SwapProvider, TRANSFER_ACCOUNT_AUTHORITY_FLAG, TransactionArenaKeyMap, TransactionBuildingError, TransactionBuildingErrorCode, TransactionConfigMap, TransactionType, U64_MAX, USDC_DECIMALS, USDC_MINT, USDT_MINT, VENUE_AVAILABLE_LIQUIDITY_BUFFER, WSOL_MINT, ZERO_ORACLE_KEY, accountConflictsWithBridgeBank, accountFlagToBN, addOracleToBanksIx, addTransactionMetadata, adjustPriceComponent, aprToApy, apyToApr, balanceToDto, bankConfigRawToDto, bankConfigToBankConfigRaw, bankMetadataMapToDto, bankMetadataToDto, bankRateLimiterRawToDto, bankRawToDto, bigNumberToWrappedI80F48, bpsToPercentile, buildCollateralLegIxs, calculateApyFromInterest, calculateInterestFromApy, capConfidenceInterval, categorizePythBanks, checkBatchOracleCrankability, checkJupiterFeeAccount, checkMultipleOraclesCrankability, checkTitanFeeAccount, chunkedGetRawMultipleAccountInfoOrdered, chunkedGetRawMultipleAccountInfoOrderedWithNulls, chunkedGetRawMultipleAccountInfos, classifyAndValidate, compileFlashloanPrecheck, composeBridgedSwap, composeRemainingAccounts, computeAccountValue, computeAccrualProjectionSeconds, computeActiveEmodePairs, computeAssetHealthComponent, computeAssetUsdValue, computeBalanceUsdValue, computeBankAvailableLiquidity, computeBankBorrowApy, computeBankBorrowCapRemaining, computeBankDepositCapRemaining, computeBankMetrics, computeBankPoolSize, computeBankProjectedAvailableLiquidity, computeBankRateLimitRemaining, computeBankRiskAccountKeys, computeBankSupplyApy, computeBankTotalBorrows, computeBankTotalBorrowsUsd, computeBankTotalDeposits, computeBankTotalDepositsUsd, computeBaseInterestRate, computeBorrowEstimateForRepay, computeClaimedEmissions, computeClosePositionTokenAmount, computeEmodeImpacts, computeFlashLoanNonSwapBudget, computeFlashloanSwapConstraints, computeFreeCollateralFromBalances, computeFreeCollateralFromCache, computeGroupRateLimitRemainingUsd, computeHealthAccountMetas, computeHealthCacheStatus, computeHealthCheckAccounts, computeHealthComponentsFromBalances, computeHealthComponentsFromCache, computeInterestRates, computeLiabilityHealthComponent, computeLiabilityUsdValue, computeLiquidationPriceForBank, computeLoopingParams, computeLowestEmodeWeights, computeMaxBorrowForBank, computeMaxDepositForBank, computeMaxLeverage, computeMaxWithdrawForBank, computeNetApy, computeProjectedActiveBalancesNoCpi, computeProjectedActiveBanksNoCpi, computePtMultiplier, computeQuantity, computeQuantityUi, computeRateLimitWindowRemainingCapacity, computeRateLimiterRemainingCapacity, computeRemainingCapacity, computeSmartCrank, computeStakedBankMultipliers, computeTotalOutstandingEmissions, computeTvl, computeUsdValue, computeUtilizationRate, computeV0TxSize, computeVenueAvailableLiquidity, convertVoteAccCoeffsToBankCoeffs, createActiveEmodePairFromPairs, createEmptyBalance, decodeAccountRaw, decodeBankRaw, decodeInstruction, decompileV0Transaction, deriveBankEmissionsAuth, deriveBankEmissionsVault, deriveBankFeeVault, deriveBankFeeVaultAuthority, deriveBankInsuranceVault, deriveBankInsuranceVaultAuthority, deriveBankLiquidityVault, deriveBankLiquidityVaultAuthority, deriveFeeState, deriveMarginfiAccount, deserializeInstruction, deserializeLut, deserializeSwapEngineRequest, deserializeSwapEngineResult, dtoToBalance, dtoToBank, dtoToBankConfig, dtoToBankConfigRaw, dtoToBankMetadata, dtoToBankMetadataMap, dtoToBankRateLimiter, dtoToBankRateLimiterRaw, dtoToBankRaw, dtoToEmodeSettings, dtoToEmodeSettingsRaw, dtoToGroup, dtoToHealthCache, dtoToInterestRateConfig, dtoToMarginfiAccount, dtoToOraclePrice, dtoToValidatorStakeGroup, emodeSettingsRawToDto, extractPythOracleKeys, fetchBank, fetchBankIntegrationMetadata, fetchGammaLpVault, fetchGammaWithdrawReceipt, fetchMarginfiAccountActiveBalancesForBank, fetchMarginfiAccountAddresses, fetchMarginfiAccountAddressesHoldingBank, fetchMarginfiAccountData, fetchMultipleBanks, fetchNativeStakeAccounts, fetchOracleData, fetchOracleMultipliers, fetchOracleMultipliersFromAPI, fetchOracleMultipliersFromChain, fetchProgramForMints, fetchPythOracleData, fetchPythOraclePricesFromAPI, fetchPythOraclePricesFromChain, fetchScopeOracleData, fetchScopeOraclePricesFromAPI, fetchScopeOraclePricesFromChain, fetchStakeAccount, fetchStakePoolActiveStates, fetchStakePoolMev, fetchSwbOracleAccountsFromAPI, fetchSwbOracleAccountsFromChain, fetchSwbOracleData, fetchSwbOraclePricesFromAPI, fetchSwbOraclePricesFromCrossbar, findRandomAvailableAccountIndex, freezeBankConfigIx, generateDummyAccount, getAccountKeys, getActiveAccountFlags, getActiveBalances, getActiveEmodeEntryFlags, getActiveEmodeFlags, getActiveHealthCacheFlags, getAssetQuantity, getAssetShares, getAssetWeight, getBalance, getBalanceUsdValueWithPriceBias, getBankVaultAuthority, getBankVaultSeeds, getBirdeyeFallbackPricesByFeedId, getBirdeyePricesForMints, getConfig, getDriftCTokenMultiplier, getDriftMetadata, getDriftStatesDto, getEffectiveDepositLimit, getEmodePairs, getExactOutEstimate, getFallbackPricesByFeedId, getFallbackPricesForMints, getHealthCacheStatusDescription, getHealthSimulationTransactions, getJupLendFTokenMultiplier, getJupLendMetadata, getJupLendStatesDto, getJupiterReferralFeeAccount, getJupiterSwapIxsForFlashloan, getKaminoCTokenMultiplier, getKaminoMetadata, getKaminoStatesDto, getLiabilityQuantity, getLiabilityShares, getLiabilityWeight, getOracleSourceFromBank, getOracleSourceFromOracleSetup, getOracleSourceNameFromKey, getPrice, getPriceWithConfidence, getStakedBankMetadataMap, getSwapAdapter, getSwapIxsForFlashloan, getTitanExactOutEstimate, getTitanSwapIxsForFlashloan, getTotalAccountKeys, getTotalAssetQuantity, getTotalLiabilityQuantity, getTxSize, getValidatorVoteAccountByBank, getWritableAccountKeys, groupToDto, hasAccountFlag, hasEmodeEntryFlag, hasEmodeFlag, hasHealthCacheFlag, healthCacheToDto, isBorrowLimitActive, isBridgeConflictError, isDecomposableSwapError, isDepositIx, isDepositLimitActive, isFlashloan, isGroupRateLimiterEnabled, isStandardBorrowable, isStandardDepositable, isV0Tx, isWeightedPrice, isWholePosition, makeAccountTransferToNewAccountTx, makeAddPermissionlessStakedBankIx, makeBeginFlashLoanIx3 as makeBeginFlashLoanIx, makeBorrowIx3 as makeBorrowIx, makeBorrowTx, makeBridgedLoopTx, makeBridgedSwapCollateralTx, makeBridgedSwapDebtTx, makeBulkRepayTx, makeBulkWithdrawTx, makeBundleTipIx, makeCloseMarginfiAccountIx, makeCloseMarginfiAccountTx, makeCrankSwbFeedIx, makeCreateAccountIxWithProjection, makeCreateAccountTxWithProjection, makeCreateMarginfiAccountIx, makeCreateMarginfiAccountTx, makeDepositIx3 as makeDepositIx, makeDepositTx, makeDriftDepositIx3 as makeDriftDepositIx, makeDriftDepositTx, makeDriftWithdrawIx3 as makeDriftWithdrawIx, makeDriftWithdrawTx, makeEndFlashLoanIx3 as makeEndFlashLoanIx, makeFlashLoanTx, makeJuplendDepositIx2 as makeJuplendDepositIx, makeJuplendDepositTx, makeJuplendWithdrawIx2 as makeJuplendWithdrawIx, makeJuplendWithdrawTx, makeKaminoDepositIx3 as makeKaminoDepositIx, makeKaminoDepositTx, makeKaminoWithdrawIx3 as makeKaminoWithdrawIx, makeKaminoWithdrawTx, makeLoopTx, makeMergeStakeAccountsTx, makeMintStakedLstIx, makeMintStakedLstTx, makePoolAddBankIx3 as makePoolAddBankIx, makePoolConfigureBankIx3 as makePoolConfigureBankIx, makePriorityFeeIx, makePriorityFeeMicroIx, makePulseHealthIx2 as makePulseHealthIx, makeRedeemStakedLstIx, makeRedeemStakedLstTx, makeRefreshIntegrationBanksIxs, makeRefreshKaminoBanksIxs, makeRepayIx3 as makeRepayIx, makeRepayTx, makeRepayWithCollatTx, makeRollPtTx, makeSetupIx, makeSmartCrankSwbFeedIx, makeSmartCrankSwbFeedIxForAccounts, makeSwapCollateralTx, makeSwapDebtTx, makeTransferPositionsTx, makeTxPriorityIx, makeUnwrapSolIx, makeUpdateDriftMarketIxs, makeUpdateJupLendRateIxs, makeUpdateSwbFeedIx, makeVaultCompleteWithdrawalIx, makeVaultCompleteWithdrawalTx, makeVaultDepositIx, makeVaultDepositTx, makeVaultDepositWithSwapTx, makeVaultWithdrawIx, makeVaultWithdrawTx, makeVersionedTransaction, makeWithdrawIx3 as makeWithdrawIx, makeWithdrawTx, makeWrapSolIxs, mapBrokenFeedsToOraclePrices, mapJupiterQuoteToSwapQuoteResult, mapPythBanksToOraclePrices, mapSwbBanksToOraclePrices, marginfiAccountToDto, mergeBridgeQuotes, mergeBridgeQuotesDebt, mergeBridgeQuotesLoop, nativeToUi, oraclePriceToDto, parseBalanceRaw, parseBankConfigRaw, parseBankRateLimiterRaw, parseBankRaw, parseEmodeSettingsRaw, parseEmodeTag, parseHealthCacheRaw, parseMarginfiAccountRaw, parseOperationalState, parseOracleSetup, parseOraclePriceData as parsePriceInfo, parseRiskTier, parseRpcPythPriceData, parseSwbOraclePriceData, partitionBanksByCrankability, patchDepositAmount, requireBank, requireTokenProgram, resolveAmount, resolveBridgeCandidateBanks, resolvePinnedSwapRoute, resolveTokenProgramForMint, resolveVaultTokenProgram, runSwapEngine, selectLutsForAccountAction, selectLutsForBanks, selectSwapBridges, serializeBankConfigOpt, serializeInstruction, serializeInterestRateConfig, serializeLut, serializeOperationalState, serializeOracleSetup, serializeOracleSetupToIndex, serializeRiskTier, serializeSwapEngineRequest, serializeSwapEngineResult, sharedBridgeLegContext, shortenAddress, simulateAccountHealthCache, simulateAccountHealthCacheWithFallback, simulateBundle, splitInstructionsToFitTransactions, swapEngineProvidersFromOpts, swapEngineQuoteFieldsFromOpts, toBankConfigDto, toBankDto, toBankRateLimiterDto, toBigNumber, toEmodeSettingsDto, toInterestRateConfigDto, toJupiterConfig, toNumber, tryBridgeCandidates, uiToNative, uiToNativeBigNumber, validatorStakeGroupToDto, wrappedI80F48toBigNumber };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map