@varla/sdk 2.17.0 → 2.18.0

package/src/views/liquidators.ts

@@ -2,6 +2,8 @@
 
 import type { Address, PublicClient } from "viem";
 
+import { multicallChunks } from "../batch.js";
+import { abis } from "../generated.js";
 import { readAccountPositionsFull } from "./core.js";
 import { type ReadPositionSnapshot, readManyPositionSnapshots } from "./oracle.js";
 
@@ -51,17 +53,8 @@ export type ReadCanLiquidate = {
   currentBonus: bigint;
 };
 
-/**
- * Normalized wrapper over `*.canLiquidate(user)`.
- */
-// wraps: VarlaLiquidator.canLiquidate,VarlaMergeLiquidator.canLiquidate,VarlaConvertLiquidator.canLiquidate
-export async function readCanLiquidate(params: {
-  liquidator: CanLiquidateLike;
-  user: Address;
-}): Promise<ReadCanLiquidate> {
-  const raw = await params.liquidator.read.canLiquidate([params.user]);
+function normalizeCanLiquidate(raw: unknown, user: Address): ReadCanLiquidate {
   const r: any = raw as any;
-
   const canLiquidate = r.canLiquidate_ ?? r.canLiquidate ?? r[0];
   const healthFactor = r.healthFactor ?? r[1];
   const currentBonus = r.currentBonus ?? r[2];
@@ -74,7 +67,56 @@ export async function readCanLiquidate(params: {
     throw new Error("Unexpected canLiquidate() return shape");
   }
 
-  return { user: params.user, canLiquidate, healthFactor, currentBonus };
+  return { user, canLiquidate, healthFactor, currentBonus };
+}
+
+/**
+ * Normalized wrapper over `*.canLiquidate(user)`.
+ */
+// wraps: VarlaLiquidator.canLiquidate,VarlaMergeLiquidator.canLiquidate,VarlaConvertLiquidator.canLiquidate
+export async function readCanLiquidate(params: {
+  liquidator: CanLiquidateLike;
+  user: Address;
+}): Promise<ReadCanLiquidate> {
+  const raw = await params.liquidator.read.canLiquidate([params.user]);
+  return normalizeCanLiquidate(raw, params.user);
+}
+
+/**
+ * Multicall-chunked version of `readCanLiquidate`.
+ */
+// wraps: VarlaLiquidator.canLiquidate,VarlaMergeLiquidator.canLiquidate,VarlaConvertLiquidator.canLiquidate
+export async function readManyCanLiquidate(params: {
+  liquidator: { address: Address };
+  client: { multicall: (args: any) => Promise<any> };
+  users: readonly Address[];
+  chunkSize?: number;
+}): Promise<ReadCanLiquidate[]> {
+  const chunkSize = params.chunkSize ?? 256;
+  if (params.users.length === 0) return [];
+
+  const calls = params.users.map((user) => ({
+    address: params.liquidator.address,
+    abi: abis.VARLALIQUIDATOR_ABI,
+    functionName: "canLiquidate" as const,
+    args: [user] as const,
+  }));
+
+  const res = await multicallChunks({
+    client: params.client as any,
+    contracts: calls as any,
+    chunkSize,
+  });
+
+  const out: ReadCanLiquidate[] = [];
+  for (let i = 0; i < res.length; i++) {
+    const r: any = (res as any[])[i];
+    if (r.status !== "success") {
+      throw new Error(`Liquidator canLiquidate multicall failed: ${String(r.error ?? "unknown")}`);
+    }
+    out.push(normalizeCanLiquidate(r.result, params.users[i]!));
+  }
+  return out;
 }
 
 type PreviewLiquidationLike = {
@@ -171,15 +213,7 @@ export type ReadBadDebtStatus = {
   shortfall: bigint;
 };
 
-/**
- * Normalized wrapper over `VarlaLiquidator.checkBadDebt(user)`.
- */
-// wraps: VarlaLiquidator.checkBadDebt
-export async function readBadDebtStatus(params: {
-  liquidator: CheckBadDebtLike;
-  user: Address;
-}): Promise<ReadBadDebtStatus> {
-  const raw = await params.liquidator.read.checkBadDebt([params.user]);
+function normalizeBadDebtStatus(raw: unknown, user: Address): ReadBadDebtStatus {
   const r: any = raw as any;
 
   const hasBadDebt = r.hasBadDebt ?? r[0];
@@ -196,7 +230,56 @@ export async function readBadDebtStatus(params: {
     throw new Error("Unexpected checkBadDebt() return shape");
   }
 
-  return { user: params.user, hasBadDebt, collateralValue, debtValue, shortfall };
+  return { user, hasBadDebt, collateralValue, debtValue, shortfall };
+}
+
+/**
+ * Normalized wrapper over `VarlaLiquidator.checkBadDebt(user)`.
+ */
+// wraps: VarlaLiquidator.checkBadDebt
+export async function readBadDebtStatus(params: {
+  liquidator: CheckBadDebtLike;
+  user: Address;
+}): Promise<ReadBadDebtStatus> {
+  const raw = await params.liquidator.read.checkBadDebt([params.user]);
+  return normalizeBadDebtStatus(raw, params.user);
+}
+
+/**
+ * Multicall-chunked version of `readBadDebtStatus`.
+ */
+// wraps: VarlaLiquidator.checkBadDebt
+export async function readManyBadDebtStatus(params: {
+  liquidator: { address: Address };
+  client: { multicall: (args: any) => Promise<any> };
+  users: readonly Address[];
+  chunkSize?: number;
+}): Promise<ReadBadDebtStatus[]> {
+  const chunkSize = params.chunkSize ?? 256;
+  if (params.users.length === 0) return [];
+
+  const calls = params.users.map((user) => ({
+    address: params.liquidator.address,
+    abi: abis.VARLALIQUIDATOR_ABI,
+    functionName: "checkBadDebt" as const,
+    args: [user] as const,
+  }));
+
+  const res = await multicallChunks({
+    client: params.client as any,
+    contracts: calls as any,
+    chunkSize,
+  });
+
+  const out: ReadBadDebtStatus[] = [];
+  for (let i = 0; i < res.length; i++) {
+    const r: any = (res as any[])[i];
+    if (r.status !== "success") {
+      throw new Error(`Liquidator checkBadDebt multicall failed: ${String(r.error ?? "unknown")}`);
+    }
+    out.push(normalizeBadDebtStatus(r.result, params.users[i]!));
+  }
+  return out;
 }
 
 type MergeLiquidatorLike = LiquidatorLike & {

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 };
+}