@varla/sdk 2.18.0 → 2.19.0

package/src/views/core.ts

@@ -904,6 +904,27 @@ export type ReadCoreDashboard = {
   ];
 };
 
+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)`.
  */
@@ -1076,6 +1097,166 @@ export async function readCoreDashboard(params: {
   };
 }
 
+/**
+ * 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;
@@ -1590,6 +1771,12 @@ type _OraclePositionSnapshot = {
   earlyClosureFactorWad: bigint;
 };
 
+type _OraclePriceData = {
+  positionId: bigint;
+  priceE8: bigint;
+  twapE8: bigint;
+};
+
 function _normalizeOraclePositionSnapshot(
   raw: unknown,
   positionId: bigint,
@@ -1621,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/system.ts

@@ -1,6 +1,6 @@
 // Note: explicit .js extension is required for Node ESM resolution.
 
-import type { 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";
@@ -25,6 +25,7 @@ export type ReadSystemSnapshot = {
 export type ReadSystemDashboardSnapshot = ReadSystemSnapshot & {
   poolSharePrice: ReadPoolSharePrice;
   poolHealthScore: ReadPoolHealthScore;
+  coreAddresses: ReadCoreAddresses;
 };
 
 /**
@@ -86,5 +87,6 @@ export async function readSystemDashboardSnapshot(params: {
     oracle,
     poolSharePrice: poolDashboard.sharePrice,
     poolHealthScore: poolDashboard.healthScore,
+    coreAddresses: coreDashboard.coreAddresses,
   };
 }