@varla/sdk 2.17.0 → 2.19.0

package/src/views/oracle.ts

@@ -275,6 +275,22 @@ export type ReadOracleTiming = {
   lastUpdated: bigint;
 };
 
+export type ReadOracleDashboardRow = {
+  positionId: bigint;
+  snapshot: ReadPositionSnapshot;
+  meta: ReadOraclePositionMeta;
+  resolvedStatus: { positionId: bigint; isResolved: boolean };
+  staleStatus: { positionId: bigint; isPriceStale: boolean };
+  priceData: ReadOraclePriceData;
+};
+
+export type ReadOracleDashboard = {
+  config: ReadOracleConfig;
+  basics: ReadOracleBasics;
+  positionIds: bigint[];
+  rows: ReadOracleDashboardRow[];
+};
+
 // wraps: VarlaOracle.getPriceData
 export async function readOraclePriceData(params: {
   oracle: {
@@ -368,6 +384,302 @@ export async function readOracleTiming(params: {
   };
 }
 
+/**
+ * Multicall-chunked collateral status hydration for many positions.
+ */
+// wraps: VarlaOracle.isConfigured,VarlaOracle.isResolved,VarlaOracle.isDepositAllowed,VarlaOracle.isValidCollateral,VarlaOracle.isPriceStale
+export async function readManyOracleCollateralStatus(params: {
+  oracle: { address: Address };
+  client: { multicall: (args: any) => Promise<any> };
+  positionIds: readonly bigint[];
+  chunkSize?: number;
+}): Promise<ReadOracleCollateralStatus[]> {
+  const chunkSize = params.chunkSize ?? 256;
+  if (params.positionIds.length === 0) return [];
+
+  const calls = params.positionIds.flatMap((pid) => [
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "isConfigured" as const,
+      args: [pid] as const,
+    },
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "isResolved" as const,
+      args: [pid] as const,
+    },
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "isDepositAllowed" as const,
+      args: [pid] as const,
+    },
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "isValidCollateral" as const,
+      args: [pid] as const,
+    },
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "isPriceStale" as const,
+      args: [pid] as const,
+    },
+  ]);
+
+  const res = await multicallChunks({
+    client: params.client as any,
+    contracts: calls as any,
+    chunkSize,
+  });
+
+  const out: ReadOracleCollateralStatus[] = [];
+  const stride = 5;
+  for (let i = 0; i < params.positionIds.length; i++) {
+    const base = i * stride;
+    const r0: any = (res as any[])[base + 0];
+    const r1: any = (res as any[])[base + 1];
+    const r2: any = (res as any[])[base + 2];
+    const r3: any = (res as any[])[base + 3];
+    const r4: any = (res as any[])[base + 4];
+    if (
+      r0.status !== "success" ||
+      r1.status !== "success" ||
+      r2.status !== "success" ||
+      r3.status !== "success" ||
+      r4.status !== "success"
+    ) {
+      throw new Error("Oracle collateral status multicall failed");
+    }
+    out.push({
+      positionId: params.positionIds[i]!,
+      isConfigured: r0.result as boolean,
+      isResolved: r1.result as boolean,
+      isDepositAllowed: r2.result as boolean,
+      isValidCollateral: r3.result as boolean,
+      isPriceStale: r4.result as boolean,
+    });
+  }
+  return out;
+}
+
+// wraps: VarlaOracle.isResolved,VarlaOracle.isPriceStale
+export async function readManyOracleStatusFlags(params: {
+  oracle: { address: Address };
+  client: { multicall: (args: any) => Promise<any> };
+  positionIds: readonly bigint[];
+  chunkSize?: number;
+}): Promise<Array<{ positionId: bigint; isResolved: boolean; isPriceStale: boolean }>> {
+  const chunkSize = params.chunkSize ?? 256;
+  if (params.positionIds.length === 0) return [];
+
+  const calls = params.positionIds.flatMap((pid) => [
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "isResolved" as const,
+      args: [pid] as const,
+    },
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "isPriceStale" as const,
+      args: [pid] as const,
+    },
+  ]);
+
+  const res = await multicallChunks({
+    client: params.client as any,
+    contracts: calls as any,
+    chunkSize,
+  });
+
+  const out: Array<{ positionId: bigint; isResolved: boolean; isPriceStale: boolean }> = [];
+  const stride = 2;
+  for (let i = 0; i < params.positionIds.length; i++) {
+    const base = i * stride;
+    const r0: any = (res as any[])[base + 0];
+    const r1: any = (res as any[])[base + 1];
+    if (r0.status !== "success" || r1.status !== "success") {
+      throw new Error("Oracle status flags multicall failed");
+    }
+    out.push({
+      positionId: params.positionIds[i]!,
+      isResolved: r0.result as boolean,
+      isPriceStale: r1.result as boolean,
+    });
+  }
+  return out;
+}
+
+/**
+ * Multicall-chunked timing hydration for many positions.
+ */
+// wraps: VarlaOracle.getEarlyClosureWindow,VarlaOracle.getEarlyClosureFactor,VarlaOracle.lastRecoveryFromStale,VarlaOracle.getLastUpdated
+export async function readManyOracleTiming(params: {
+  oracle: { address: Address };
+  client: { multicall: (args: any) => Promise<any> };
+  positionIds: readonly bigint[];
+  chunkSize?: number;
+}): Promise<ReadOracleTiming[]> {
+  const chunkSize = params.chunkSize ?? 256;
+  if (params.positionIds.length === 0) return [];
+
+  const calls = params.positionIds.flatMap((pid) => [
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "getEarlyClosureWindow" as const,
+      args: [pid] as const,
+    },
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "getEarlyClosureFactor" as const,
+      args: [pid] as const,
+    },
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "lastRecoveryFromStale" as const,
+      args: [pid] as const,
+    },
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "getLastUpdated" as const,
+      args: [pid] as const,
+    },
+  ]);
+
+  const res = await multicallChunks({
+    client: params.client as any,
+    contracts: calls as any,
+    chunkSize,
+  });
+
+  const out: ReadOracleTiming[] = [];
+  const stride = 4;
+  for (let i = 0; i < params.positionIds.length; i++) {
+    const base = i * stride;
+    const r0: any = (res as any[])[base + 0];
+    const r1: any = (res as any[])[base + 1];
+    const r2: any = (res as any[])[base + 2];
+    const r3: any = (res as any[])[base + 3];
+    if (
+      r0.status !== "success" ||
+      r1.status !== "success" ||
+      r2.status !== "success" ||
+      r3.status !== "success"
+    ) {
+      throw new Error("Oracle timing multicall failed");
+    }
+    out.push({
+      positionId: params.positionIds[i]!,
+      earlyClosureWindow: r0.result as bigint,
+      earlyClosureFactorWad: r1.result as bigint,
+      lastRecoveryFromStale: r2.result as bigint,
+      lastUpdated: r3.result as bigint,
+    });
+  }
+  return out;
+}
+
+/**
+ * Multicall-chunked tryGetPrice hydration for many positions.
+ */
+// wraps: VarlaOracle.tryGetPrice
+export async function readManyTryGetPrice(params: {
+  oracle: { address: Address };
+  client: { multicall: (args: any) => Promise<any> };
+  positionIds: readonly bigint[];
+  chunkSize?: number;
+}): Promise<ReadTryGetPrice[]> {
+  const chunkSize = params.chunkSize ?? 256;
+  if (params.positionIds.length === 0) return [];
+
+  const calls = params.positionIds.map((pid) => ({
+    address: params.oracle.address,
+    abi: abis.VARLAORACLE_ABI,
+    functionName: "tryGetPrice" as const,
+    args: [pid] as const,
+  }));
+
+  const res = await multicallChunks({
+    client: params.client as any,
+    contracts: calls as any,
+    chunkSize,
+  });
+
+  const out: ReadTryGetPrice[] = [];
+  for (let i = 0; i < res.length; i++) {
+    const r: any = (res as any[])[i];
+    if (r.status !== "success") {
+      throw new Error(`Oracle tryGetPrice multicall failed: ${String(r.error ?? "unknown")}`);
+    }
+    out.push(
+      await readTryGetPrice({
+        oracle: {
+          read: {
+            tryGetPrice: async () => r.result,
+          },
+        } as any,
+        positionId: params.positionIds[i]!,
+      }),
+    );
+  }
+  return out;
+}
+
+/**
+ * Multicall-chunked price data hydration for many positions.
+ */
+// wraps: VarlaOracle.getPriceData
+export async function readManyOraclePriceData(params: {
+  oracle: { address: Address };
+  client: { multicall: (args: any) => Promise<any> };
+  positionIds: readonly bigint[];
+  chunkSize?: number;
+}): Promise<ReadOraclePriceData[]> {
+  const chunkSize = params.chunkSize ?? 256;
+  if (params.positionIds.length === 0) return [];
+
+  const calls = params.positionIds.map((pid) => ({
+    address: params.oracle.address,
+    abi: abis.VARLAORACLE_ABI,
+    functionName: "getPriceData" as const,
+    args: [pid] as const,
+  }));
+
+  const res = await multicallChunks({
+    client: params.client as any,
+    contracts: calls as any,
+    chunkSize,
+  });
+
+  const out: ReadOraclePriceData[] = [];
+  for (let i = 0; i < res.length; i++) {
+    const r: any = (res as any[])[i];
+    if (r.status !== "success") {
+      throw new Error(`Oracle getPriceData multicall failed: ${String(r.error ?? "unknown")}`);
+    }
+    out.push(
+      await readOraclePriceData({
+        oracle: {
+          read: {
+            getPriceData: async () => r.result,
+          },
+        } as any,
+        positionId: params.positionIds[i]!,
+      }),
+    );
+  }
+  return out;
+}
+
 // wraps: VarlaOracle.getConfiguredPositions
 export async function readConfiguredPositionIds(params: {
   oracle: {
@@ -457,7 +769,7 @@ function normalizePositionSnapshot(raw: unknown, positionId: bigint): ReadPositi
   const priceE8 = r.priceE8 ?? r[1];
   const manuallyInvalidated = r.manuallyInvalidated ?? r[2];
   const riskTier = r.riskTier ?? r[3];
-  const earlyClosureFactorWad = r.earlyClosureFactorWad ?? r[4];
+  const earlyClosureFactorWad = r.earlyClosureFactorWad ?? r.ltvAdjustmentFactorWad ?? r[4];
   const lastRecoveryFromStale = r.lastRecoveryFromStale_ ?? r.lastRecoveryFromStale ?? r[5];
   const isFinalized = r.isFinalized_ ?? r.isFinalized ?? r[6];
 
@@ -741,3 +1053,78 @@ export async function hydrateOraclePositionIds(params: {
   ]);
   return { positionIds: [...params.positionIds], snapshots, meta };
 }
+
+/**
+ * Aggregate reader for the admin Oracle page.
+ */
+// wraps: VarlaOracle.maxStaleness,VarlaOracle.liquidationGracePeriod,VarlaOracle.defaultEarlyClosureWindow,VarlaOracle.updater,VarlaOracle.collateralDecimals,VarlaOracle.getConfiguredPositions,VarlaOracle.getPositionSnapshot,VarlaOracle.getConditionId,VarlaOracle.getResolutionTime,VarlaOracle.getOppositePositionId,VarlaOracle.isNegRisk,VarlaOracle.getNegRiskMarketId,VarlaOracle.isManuallyInvalidated,VarlaOracle.isConfigured,VarlaOracle.isResolved,VarlaOracle.isDepositAllowed,VarlaOracle.isValidCollateral,VarlaOracle.isPriceStale,VarlaOracle.getEarlyClosureWindow,VarlaOracle.getEarlyClosureFactor,VarlaOracle.lastRecoveryFromStale,VarlaOracle.getLastUpdated,VarlaOracle.tryGetPrice,VarlaOracle.getPriceData
+export async function readOracleDashboard(params: {
+  oracle: {
+    address: Address;
+    read: {
+      maxStaleness: () => Promise<bigint>;
+      liquidationGracePeriod: () => Promise<bigint>;
+      defaultEarlyClosureWindow: () => Promise<bigint>;
+      updater: () => Promise<Address>;
+      collateralDecimals: () => Promise<number | bigint>;
+      getConfiguredPositions: () => Promise<readonly bigint[]>;
+    };
+  };
+  client: { multicall: (args: any) => Promise<any> };
+  chunkSize?: number;
+}): Promise<ReadOracleDashboard> {
+  const chunkSize = params.chunkSize ?? 256;
+  const [config, basics, positionIds] = await Promise.all([
+    readOracleConfig({ oracle: params.oracle }),
+    readOracleBasics({ oracle: params.oracle }),
+    readConfiguredPositionIds({ oracle: params.oracle }),
+  ]);
+
+  if (positionIds.length === 0) {
+    return { config, basics, positionIds: [], rows: [] };
+  }
+
+  const [snapshots, meta, statusFlags, priceData] = await Promise.all([
+    readManyPositionSnapshots({
+      oracle: { address: params.oracle.address },
+      client: params.client,
+      positionIds,
+      chunkSize,
+    }),
+    readManyOraclePositionMeta({
+      oracle: { address: params.oracle.address },
+      client: params.client,
+      positionIds,
+      chunkSize,
+    }),
+    readManyOracleStatusFlags({
+      oracle: { address: params.oracle.address },
+      client: params.client,
+      positionIds,
+      chunkSize,
+    }),
+    readManyOraclePriceData({
+      oracle: { address: params.oracle.address },
+      client: params.client,
+      positionIds,
+      chunkSize,
+    }),
+  ]);
+
+  const rows = positionIds.map((positionId, i) => ({
+    positionId,
+    snapshot: snapshots[i]!,
+    meta: meta[i]!,
+    resolvedStatus: {
+      positionId,
+      isResolved: statusFlags[i]!.isResolved,
+    },
+    staleStatus: {
+      positionId,
+      isPriceStale: statusFlags[i]!.isPriceStale,
+    },
+    priceData: priceData[i]!,
+  }));
+
+  return { config, basics, positionIds, rows };
+}

package/src/views/pool.ts

@@ -1,6 +1,8 @@
 // Note: explicit .js extension is required for Node ESM resolution.
 
 import type { Address } from "viem";
+import { multicallChunks } from "../batch.js";
+import { abis } from "../generated.js";
 
 export type ReadPoolSnapshot = {
   totalAssets: bigint;
@@ -154,6 +156,16 @@ export type ReadPoolHealthScore =
       kind: "no-liquidity";
     };
 
+export type ReadPoolDashboard = {
+  snapshot: ReadPoolSnapshot;
+  caps: ReadPoolCaps;
+  accounting: ReadPoolAccounting;
+  rates: ReadPoolRates;
+  sharePrice: ReadPoolSharePrice;
+  healthScore: ReadPoolHealthScore;
+  debtState: ReadPoolDebtState;
+};
+
 /**
  * Reads pool “rates” and near-term capacity in one convenience call.
  */
@@ -275,3 +287,144 @@ export async function readPoolCoreAddress(params: {
 }): Promise<Address> {
   return params.pool.read.varlaCore();
 }
+
+/**
+ * Multicall-backed aggregate reader for pool-heavy UIs.
+ *
+ * Deduplicates the overlapping primitives used across snapshot/caps/accounting/rates/share price
+ * so frontends can hydrate the full pool page with one batched request group.
+ */
+// wraps: VarlaPool.getPoolStats,VarlaPool.depositCap,VarlaPool.borrowCap,VarlaPool.reserveBalance,VarlaPool.scaledTotalBorrowed,VarlaPool.lastUpdateTimestamp,VarlaPool.totalSupply,VarlaPool.maxBorrow,VarlaPool.getCurrentBorrowIndex
+export async function readPoolDashboard(params: {
+  pool: { address: Address };
+  client: { multicall: (args: any) => Promise<any> };
+  chunkSize?: number;
+}): Promise<ReadPoolDashboard> {
+  const chunkSize = params.chunkSize ?? 256;
+
+  const calls = [
+    {
+      address: params.pool.address,
+      abi: abis.VARLAPOOL_ABI,
+      functionName: "getPoolStats" as const,
+    },
+    {
+      address: params.pool.address,
+      abi: abis.VARLAPOOL_ABI,
+      functionName: "depositCap" as const,
+    },
+    {
+      address: params.pool.address,
+      abi: abis.VARLAPOOL_ABI,
+      functionName: "borrowCap" as const,
+    },
+    {
+      address: params.pool.address,
+      abi: abis.VARLAPOOL_ABI,
+      functionName: "reserveBalance" as const,
+    },
+    {
+      address: params.pool.address,
+      abi: abis.VARLAPOOL_ABI,
+      functionName: "scaledTotalBorrowed" as const,
+    },
+    {
+      address: params.pool.address,
+      abi: abis.VARLAPOOL_ABI,
+      functionName: "lastUpdateTimestamp" as const,
+    },
+    {
+      address: params.pool.address,
+      abi: abis.VARLAPOOL_ABI,
+      functionName: "totalSupply" as const,
+    },
+    {
+      address: params.pool.address,
+      abi: abis.VARLAPOOL_ABI,
+      functionName: "maxBorrow" as const,
+    },
+    {
+      address: params.pool.address,
+      abi: abis.VARLAPOOL_ABI,
+      functionName: "getCurrentBorrowIndex" as const,
+    },
+  ];
+
+  const res = await multicallChunks({
+    client: params.client as any,
+    contracts: calls as any,
+    chunkSize,
+  });
+
+  for (const r of res as any[]) {
+    if (r.status !== "success") {
+      throw new Error(`Pool dashboard multicall failed: ${String(r.error ?? "unknown")}`);
+    }
+  }
+
+  const snapshot = await readPoolSnapshot({
+    pool: {
+      read: {
+        getPoolStats: async () => (res as any[])[0]!.result,
+      },
+    },
+  });
+
+  const depositCap = (res as any[])[1]!.result as bigint;
+  const borrowCap = (res as any[])[2]!.result as bigint;
+  const reserveBalance = (res as any[])[3]!.result as bigint;
+  const scaledTotalBorrowed = (res as any[])[4]!.result as bigint;
+  const lastUpdateTimestamp = BigInt((res as any[])[5]!.result);
+  const totalShares = (res as any[])[6]!.result as bigint;
+  const maxBorrow = (res as any[])[7]!.result as bigint;
+  const currentBorrowIndex = (res as any[])[8]!.result as bigint;
+
+  const sharePrice: ReadPoolSharePrice = {
+    totalAssets: snapshot.totalAssets,
+    totalShares,
+    assetsPerShareWad:
+      totalShares === 0n ? 0n : (snapshot.totalAssets * 1_000_000_000_000_000_000n) / totalShares,
+  };
+
+  const healthScore: ReadPoolHealthScore =
+    snapshot.totalAssets === 0n
+      ? { kind: "no-liquidity" }
+      : {
+          kind: "ok",
+          utilizationWad: snapshot.utilization,
+          scoreBps:
+            ((1_000_000_000_000_000_000n -
+              (snapshot.utilization > 1_000_000_000_000_000_000n
+                ? 1_000_000_000_000_000_000n
+                : snapshot.utilization < 0n
+                  ? 0n
+                  : snapshot.utilization)) *
+              10_000n) /
+            1_000_000_000_000_000_000n,
+        };
+
+  return {
+    snapshot,
+    caps: { depositCap, borrowCap },
+    accounting: {
+      reserveBalance,
+      scaledTotalBorrowed,
+      borrowIndex: snapshot.borrowIndex,
+      lastUpdateTimestamp,
+    },
+    rates: {
+      utilization: snapshot.utilization,
+      borrowRate: snapshot.borrowRate,
+      supplyAPY: snapshot.supplyAPY,
+      availableLiquidity: snapshot.available,
+      maxBorrow,
+    },
+    sharePrice,
+    healthScore,
+    debtState: {
+      totalBorrowed: snapshot.totalBorrowed,
+      currentBorrowIndex,
+      borrowRate: snapshot.borrowRate,
+    },
+  };
+}

package/src/views/system.ts

@@ -1,11 +1,17 @@
 // Note: explicit .js extension is required for Node ESM resolution.
 
-import type { ReadDefaultLtvConfig, ReadLiquidationConfig } from "./core.js";
-import { readDefaultLtvConfig, readLiquidationConfig } from "./core.js";
+import type { ReadCoreAddresses, ReadDefaultLtvConfig, ReadLiquidationConfig } from "./core.js";
+import { readCoreDashboard, readDefaultLtvConfig, readLiquidationConfig } from "./core.js";
 import type { ReadOracleConfig } from "./oracle.js";
 import { readOracleConfig } from "./oracle.js";
-import type { ReadPoolAccounting, ReadPoolCaps, ReadPoolSnapshot } from "./pool.js";
-import { readPoolAccounting, readPoolCaps, readPoolSnapshot } from "./pool.js";
+import type {
+  ReadPoolAccounting,
+  ReadPoolCaps,
+  ReadPoolHealthScore,
+  ReadPoolSharePrice,
+  ReadPoolSnapshot,
+} from "./pool.js";
+import { readPoolAccounting, readPoolCaps, readPoolDashboard, readPoolSnapshot } from "./pool.js";
 
 export type ReadSystemSnapshot = {
   pool: ReadPoolSnapshot;
@@ -16,6 +22,12 @@ export type ReadSystemSnapshot = {
   oracle: ReadOracleConfig;
 };
 
+export type ReadSystemDashboardSnapshot = ReadSystemSnapshot & {
+  poolSharePrice: ReadPoolSharePrice;
+  poolHealthScore: ReadPoolHealthScore;
+  coreAddresses: ReadCoreAddresses;
+};
+
 /**
  * A lightweight “global protocol state” read for dashboards.
  *
@@ -40,3 +52,41 @@ export async function readSystemSnapshot(params: {
 
   return { pool, poolCaps, poolAccounting, coreLtv, coreLiquidation, oracle };
 }
+
+/**
+ * Multicall-backed system snapshot used by dashboards.
+ */
+export async function readSystemDashboardSnapshot(params: {
+  pool: { address: `0x${string}` };
+  core: { address: `0x${string}` };
+  oracle: any;
+  client: { multicall: (args: any) => Promise<any> };
+}): Promise<ReadSystemDashboardSnapshot> {
+  const [poolDashboard, coreDashboard, oracle] = await Promise.all([
+    readPoolDashboard({
+      pool: { address: params.pool.address },
+      client: params.client,
+    }),
+    readCoreDashboard({
+      core: { address: params.core.address },
+      client: params.client,
+    }),
+    readOracleConfig({ oracle: params.oracle }),
+  ]);
+
+  return {
+    pool: poolDashboard.snapshot,
+    poolCaps: poolDashboard.caps,
+    poolAccounting: poolDashboard.accounting,
+    coreLtv: {
+      conservative: coreDashboard.ltvConfig.tier0,
+      moderate: coreDashboard.ltvConfig.tier1,
+      risk: coreDashboard.ltvConfig.tier2,
+    },
+    coreLiquidation: coreDashboard.liqConfig,
+    oracle,
+    poolSharePrice: poolDashboard.sharePrice,
+    poolHealthScore: poolDashboard.healthScore,
+    coreAddresses: coreDashboard.coreAddresses,
+  };
+}