@varla/sdk 2.17.0 → 2.19.0

package/src/views/core.ts

@@ -891,6 +891,40 @@ export type ReadTierLiquidationConfig = {
   liquidationFeeBps: bigint;
 };
 
+export type ReadCoreDashboard = {
+  globalDebt: ReadCoreGlobalDebt;
+  coreAddresses: ReadCoreAddresses;
+  maxPositions: ReadMaxPositionsConfig;
+  ltvConfig: ReadTieredLtvConfig;
+  liqConfig: ReadLiquidationConfig;
+  tierLiq: readonly [
+    ReadTierLiquidationConfig | null,
+    ReadTierLiquidationConfig | null,
+    ReadTierLiquidationConfig | null,
+  ];
+};
+
+export type ReadConfiguredPositionDepositRow = {
+  positionId: bigint;
+  conditionId: `0x${string}`;
+  depositedBalance: bigint;
+  priceOk: boolean;
+  spotPriceE8: bigint;
+  twapPriceE8: bigint;
+  priceE8: bigint;
+  effectivePriceE8: bigint;
+  usedFallbackPrice: boolean;
+  depositValue: bigint;
+};
+
+export type ReadConfiguredPositionDepositsSummary = {
+  configuredCount: number;
+  pricedCount: number;
+  totalDepositedBalance: bigint;
+  totalDepositedValue: bigint;
+  rows: ReadConfiguredPositionDepositRow[];
+};
+
 /**
  * Normalized wrapper over `VarlaCore.getTierLiquidationConfig(tier)`.
  */
@@ -915,6 +949,314 @@ export async function readTierLiquidationConfig(params: {
   return { tier: params.tier, maxLiquidationBonusBps, liquidationFeeBps };
 }
 
+/**
+ * Multicall-backed aggregate reader for the admin Core page.
+ */
+// wraps: VarlaCore.totalScaledDebt,VarlaCore.collateralToken,VarlaCore.positionsToken,VarlaCore.pool,VarlaCore.oracle,VarlaCore.collateralDecimals,VarlaCore.maxPositions,VarlaCore.minMaxPositions,VarlaCore.maxMaxPositions,VarlaCore.getDefaultLtvConfig,VarlaCore.getLiquidationConfig,VarlaCore.getTierLiquidationConfig
+export async function readCoreDashboard(params: {
+  core: { address: Address };
+  client: { multicall: (args: any) => Promise<any> };
+  chunkSize?: number;
+}): Promise<ReadCoreDashboard> {
+  const chunkSize = params.chunkSize ?? 256;
+
+  const calls = [
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "totalScaledDebt" as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "collateralToken" as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "positionsToken" as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "pool" as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "oracle" as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "collateralDecimals" as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "maxPositions" as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "minMaxPositions" as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "maxMaxPositions" as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "getDefaultLtvConfig" as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "getLiquidationConfig" as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "getTierLiquidationConfig" as const,
+      args: [0] as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "getTierLiquidationConfig" as const,
+      args: [1] as const,
+    },
+    {
+      address: params.core.address,
+      abi: abis.VARLACORE_ABI,
+      functionName: "getTierLiquidationConfig" as const,
+      args: [2] as const,
+    },
+  ];
+
+  const res = await multicallChunks({
+    client: params.client as any,
+    contracts: calls as any,
+    chunkSize,
+  });
+
+  const ensureSuccess = (r: any, label: string) => {
+    if (r.status !== "success") {
+      throw new Error(`Core dashboard ${label} multicall failed: ${String(r.error ?? "unknown")}`);
+    }
+    return r.result;
+  };
+
+  const totalScaledDebt = ensureSuccess((res as any[])[0], "totalScaledDebt") as bigint;
+  const collateralToken = ensureSuccess((res as any[])[1], "collateralToken") as Address;
+  const positionsToken = ensureSuccess((res as any[])[2], "positionsToken") as Address;
+  const pool = ensureSuccess((res as any[])[3], "pool") as Address;
+  const oracle = ensureSuccess((res as any[])[4], "oracle") as Address;
+  const collateralDecimalsRaw = ensureSuccess((res as any[])[5], "collateralDecimals") as
+    | bigint
+    | number;
+  const maxPositions = ensureSuccess((res as any[])[6], "maxPositions") as bigint;
+  const minMaxPositions = ensureSuccess((res as any[])[7], "minMaxPositions") as bigint;
+  const maxMaxPositions = ensureSuccess((res as any[])[8], "maxMaxPositions") as bigint;
+  const defaultLtvRaw = ensureSuccess((res as any[])[9], "getDefaultLtvConfig");
+  const liqRaw = ensureSuccess((res as any[])[10], "getLiquidationConfig");
+  const tier0Raw = ensureSuccess((res as any[])[11], "getTierLiquidationConfig(0)");
+  const tier1Raw = ensureSuccess((res as any[])[12], "getTierLiquidationConfig(1)");
+  const tier2Raw = ensureSuccess((res as any[])[13], "getTierLiquidationConfig(2)");
+
+  const coreLike = {
+    read: {
+      getDefaultLtvConfig: async () => defaultLtvRaw,
+      getLiquidationConfig: async () => liqRaw,
+      getTierLiquidationConfig: async (args: readonly [number]) => {
+        if (args[0] === 0) return tier0Raw;
+        if (args[0] === 1) return tier1Raw;
+        return tier2Raw;
+      },
+    },
+  } as any;
+
+  const collateralDecimals =
+    typeof collateralDecimalsRaw === "bigint"
+      ? Number(collateralDecimalsRaw)
+      : collateralDecimalsRaw;
+
+  return {
+    globalDebt: { totalScaledDebt },
+    coreAddresses: { collateralToken, positionsToken, pool, oracle, collateralDecimals },
+    maxPositions: { maxPositions, minMaxPositions, maxMaxPositions },
+    ltvConfig: await readTieredLtvConfig({ core: coreLike }),
+    liqConfig: await readLiquidationConfig({ core: coreLike }),
+    tierLiq: [
+      await readTierLiquidationConfig({ core: coreLike, tier: 0 }),
+      await readTierLiquidationConfig({ core: coreLike, tier: 1 }),
+      await readTierLiquidationConfig({ core: coreLike, tier: 2 }),
+    ] as const,
+  };
+}
+
+/**
+ * Reads deposited balances for all oracle-configured positions.
+ *
+ * Uses:
+ * - `oracle.getConfiguredPositions()`
+ * - `positionsToken.balanceOf(core, positionId)`
+ * - `oracle.getPositionSnapshot(positionId)` for pricing
+ * - `oracle.getPriceData(positionId)` for fallback pricing
+ * - `oracle.getConditionId(positionId)` for market mapping
+ */
+// wraps: VarlaOracle.getConfiguredPositions,ERC1155.balanceOf,VarlaOracle.getPositionSnapshot,VarlaOracle.getPriceData,VarlaOracle.getConditionId
+export async function readConfiguredPositionDepositsSummary(params: {
+  core: { address: Address };
+  oracle: { address: Address };
+  positionsToken: { address: Address };
+  client: { multicall: (args: any) => Promise<any> };
+  chunkSize?: number;
+}): Promise<ReadConfiguredPositionDepositsSummary> {
+  const chunkSize = params.chunkSize ?? 256;
+
+  const cfgRes = await multicallChunks({
+    client: params.client as any,
+    contracts: [
+      {
+        address: params.oracle.address,
+        abi: abis.VARLAORACLE_ABI,
+        functionName: "getConfiguredPositions" as const,
+      },
+    ] as any,
+    chunkSize,
+  });
+
+  const cfg0: any = (cfgRes as any[])[0];
+  if (!cfg0 || cfg0.status !== "success" || !Array.isArray(cfg0.result)) {
+    throw new Error(`Configured positions read failed: ${String(cfg0?.error ?? "unknown")}`);
+  }
+
+  const positionIds = [...(cfg0.result as readonly bigint[])];
+  if (positionIds.length === 0) {
+    return {
+      configuredCount: 0,
+      pricedCount: 0,
+      totalDepositedBalance: 0n,
+      totalDepositedValue: 0n,
+      rows: [],
+    };
+  }
+
+  const calls = positionIds.flatMap((pid) => [
+    {
+      address: params.positionsToken.address,
+      abi: erc1155Abi,
+      functionName: "balanceOf" as const,
+      args: [params.core.address, pid] as const,
+    },
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "getPositionSnapshot" as const,
+      args: [pid] as const,
+    },
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "getPriceData" as const,
+      args: [pid] as const,
+    },
+    {
+      address: params.oracle.address,
+      abi: abis.VARLAORACLE_ABI,
+      functionName: "getConditionId" as const,
+      args: [pid] as const,
+    },
+  ]);
+
+  const res = await multicallChunks({
+    client: params.client as any,
+    contracts: calls as any,
+    chunkSize,
+  });
+
+  const rows: ReadConfiguredPositionDepositRow[] = [];
+  let totalDepositedBalance = 0n;
+  let totalDepositedValue = 0n;
+  let pricedCount = 0;
+
+  for (let i = 0; i < positionIds.length; i++) {
+    const balR: any = (res as any[])[i * 4];
+    const snapR: any = (res as any[])[i * 4 + 1];
+    const priceR: any = (res as any[])[i * 4 + 2];
+    const condR: any = (res as any[])[i * 4 + 3];
+    const pid = positionIds[i]!;
+
+    if (balR?.status !== "success") {
+      throw new Error(
+        `Configured position balance read failed: ${String(balR?.error ?? "unknown")}`,
+      );
+    }
+    if (snapR?.status !== "success") {
+      throw new Error(
+        `Configured position snapshot read failed: ${String(snapR?.error ?? "unknown")}`,
+      );
+    }
+    if (priceR?.status !== "success") {
+      throw new Error(
+        `Configured position priceData read failed: ${String(priceR?.error ?? "unknown")}`,
+      );
+    }
+    if (condR?.status !== "success") {
+      throw new Error(
+        `Configured position condition read failed: ${String(condR?.error ?? "unknown")}`,
+      );
+    }
+
+    const depositedBalance = balR.result as bigint;
+    if (typeof depositedBalance !== "bigint") {
+      throw new Error("Unexpected ERC1155.balanceOf return type");
+    }
+
+    const snap = _normalizeOraclePositionSnapshot(snapR.result, pid);
+    const priceData = _normalizeOraclePriceData(priceR.result, pid);
+    const conditionId = condR.result as `0x${string}`;
+    if (typeof conditionId !== "string" || !conditionId.startsWith("0x")) {
+      throw new Error("Unexpected getConditionId() return shape");
+    }
+
+    const fallbackPriceE8 = _minPositive(priceData.priceE8, priceData.twapE8);
+    const hasSnapshotPrice = snap.priceOk && snap.priceE8 > 0n;
+    const effectivePriceE8 = hasSnapshotPrice ? snap.priceE8 : fallbackPriceE8;
+    const priced = effectivePriceE8 > 0n;
+    const usedFallbackPrice = !hasSnapshotPrice && priced;
+    const depositValue = priced ? (depositedBalance * effectivePriceE8) / _E8 : 0n;
+
+    totalDepositedBalance += depositedBalance;
+    totalDepositedValue += depositValue;
+    if (priced) pricedCount += 1;
+
+    rows.push({
+      positionId: pid,
+      conditionId,
+      depositedBalance,
+      priceOk: snap.priceOk,
+      spotPriceE8: priceData.priceE8,
+      twapPriceE8: priceData.twapE8,
+      priceE8: snap.priceE8,
+      effectivePriceE8,
+      usedFallbackPrice,
+      depositValue,
+    });
+  }
+
+  return {
+    configuredCount: positionIds.length,
+    pricedCount,
+    totalDepositedBalance,
+    totalDepositedValue,
+    rows,
+  };
+}
+
 export type ReadLiquidationParamsForPosition = {
   positionId: bigint;
   maxLiquidationBonusBps: bigint;
@@ -1429,6 +1771,12 @@ type _OraclePositionSnapshot = {
   earlyClosureFactorWad: bigint;
 };
 
+type _OraclePriceData = {
+  positionId: bigint;
+  priceE8: bigint;
+  twapE8: bigint;
+};
+
 function _normalizeOraclePositionSnapshot(
   raw: unknown,
   positionId: bigint,
@@ -1460,6 +1808,31 @@ function _normalizeOraclePositionSnapshot(
   };
 }
 
+function _normalizeOraclePriceData(raw: unknown, positionId: bigint): _OraclePriceData {
+  const r: any = raw as any;
+  const priceE8 = r.price ?? r[0];
+  const twapE8 = r.twap ?? r[1];
+
+  if (typeof priceE8 !== "bigint" || typeof twapE8 !== "bigint") {
+    throw new Error("Unexpected getPriceData() return shape");
+  }
+
+  return {
+    positionId,
+    priceE8,
+    twapE8,
+  };
+}
+
+function _minPositive(a: bigint, b: bigint): bigint {
+  const aOk = a > 0n;
+  const bOk = b > 0n;
+  if (aOk && bOk) return a < b ? a : b;
+  if (aOk) return a;
+  if (bOk) return b;
+  return 0n;
+}
+
 function _tierDefaultLtv(defaultLtv: ReadDefaultLtvConfig, riskTier: number): bigint {
   if (riskTier === 0) return defaultLtv.conservative;
   if (riskTier === 1) return defaultLtv.moderate;

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 & {