@varla/sdk 2.9.0 → 2.11.0

package/src/views/core.ts

@@ -11,6 +11,191 @@ import { abis } from "../generated.js";
 const _WAD = 1_000_000_000_000_000_000n;
 const _E8 = 100_000_000n;
 
+// ---------------------------------------------------------------------------
+// Deposit pre-flight (previewCoreDeposit)
+// ---------------------------------------------------------------------------
+
+/**
+ * Reason a deposit would be rejected for a specific position.
+ *
+ * - `"zero-amount"` — caller passed `amount === 0n`.
+ * - `"not-configured"` — position has never been configured in the oracle.
+ * - `"deposit-not-allowed"` — position is in early-closure window or already resolved.
+ * - `"invalid-collateral"` — oracle reports the position as invalid collateral
+ *   (stale price, low liquidity, manually invalidated, etc.).
+ */
+export type DepositBlockReason =
+  | "zero-amount"
+  | "not-configured"
+  | "deposit-not-allowed"
+  | "invalid-collateral";
+
+export type PreviewCoreDepositItem = {
+  positionId: bigint;
+  amount: bigint;
+  /** `true` when this individual position passes all pre-flight checks. */
+  ok: boolean;
+  /** Present only when `ok === false`. */
+  reason?: DepositBlockReason;
+};
+
+export type PreviewCoreDeposit = {
+  /** `true` only when every position passes AND account-level checks pass. */
+  canDeposit: boolean;
+  /** Per-position results aligned to input order. */
+  items: PreviewCoreDepositItem[];
+  /** Current deposited position count for the user. */
+  currentPositionCount: bigint;
+  /** Max positions allowed by Core. */
+  maxPositions: bigint;
+  /**
+   * Whether the deposit would exceed the max-positions limit.
+   *
+   * Only `true` when depositing would push the count above `maxPositions`.
+   * New positions (not already deposited) are counted.
+   */
+  wouldExceedMaxPositions: boolean;
+};
+
+/**
+ * Pre-flight check that mirrors VarlaCore.deposit() validation.
+ *
+ * Frontends should call this **before** `prepareCoreDeposit` to show clear,
+ * actionable error messages instead of raw revert data.
+ *
+ * Checks (per position):
+ * 1. `amount > 0`
+ * 2. `oracle.isDepositAllowed(positionId)` — blocks inside early-closure window / post-resolution
+ * 3. `oracle.isValidCollateral(positionId)` — stale, low-liquidity, or manually invalidated
+ *
+ * Also enriches with `oracle.isConfigured()` so the frontend can distinguish
+ * "not configured" (market not listed) from "early-closure" (market closing soon).
+ *
+ * Account-level check:
+ * - Would the deposit exceed `maxPositions`?
+ *
+ * @example
+ * ```ts
+ * import { previewCoreDeposit } from "@varla/sdk/views";
+ *
+ * const preview = await previewCoreDeposit({
+ *   oracle, core,
+ *   user: "0x...",
+ *   positionIds: [posId],
+ *   amounts: [amount],
+ * });
+ *
+ * if (!preview.canDeposit) {
+ *   for (const item of preview.items) {
+ *     if (!item.ok) console.log(`Position ${item.positionId}: ${item.reason}`);
+ *   }
+ *   if (preview.wouldExceedMaxPositions) console.log("Too many positions");
+ * }
+ * ```
+ */
+// wraps: VarlaOracle.isConfigured,VarlaOracle.isDepositAllowed,VarlaOracle.isValidCollateral,VarlaCore.getPositionCount,VarlaCore.maxPositions,VarlaCore.positionBalances
+export async function previewCoreDeposit(params: {
+  oracle: {
+    read: {
+      isConfigured: (args: readonly [bigint]) => Promise<boolean>;
+      isDepositAllowed: (args: readonly [bigint]) => Promise<boolean>;
+      isValidCollateral: (args: readonly [bigint]) => Promise<boolean>;
+    };
+  };
+  core: {
+    read: {
+      getPositionCount: (args: readonly [Address]) => Promise<bigint>;
+      maxPositions: () => Promise<bigint>;
+      positionBalances: (args: readonly [Address, bigint]) => Promise<bigint>;
+    };
+  };
+  user: Address;
+  positionIds: readonly bigint[];
+  amounts: readonly bigint[];
+}): Promise<PreviewCoreDeposit> {
+  const { oracle, core, user, positionIds, amounts } = params;
+
+  if (positionIds.length !== amounts.length) {
+    throw new Error("positionIds and amounts must have the same length");
+  }
+
+  // Parallel: oracle checks per-position + account-level reads.
+  const [oracleResults, positionCount, maxPositions, existingBalances] = await Promise.all([
+    // Per-position oracle checks (all in parallel).
+    Promise.all(
+      positionIds.map(async (pid) => {
+        const [isConfigured, isDepositAllowed, isValidCollateral] = await Promise.all([
+          oracle.read.isConfigured([pid]),
+          oracle.read.isDepositAllowed([pid]),
+          oracle.read.isValidCollateral([pid]),
+        ]);
+        return { isConfigured, isDepositAllowed, isValidCollateral };
+      }),
+    ),
+    // Account-level.
+    core.read.getPositionCount([user]),
+    core.read.maxPositions(),
+    // Check which positions user already has deposited (for max-positions calc).
+    Promise.all(positionIds.map((pid) => core.read.positionBalances([user, pid]))),
+  ]);
+
+  // Build per-position items.
+  const items: PreviewCoreDepositItem[] = [];
+  let allItemsOk = true;
+
+  for (let i = 0; i < positionIds.length; i++) {
+    const pid = positionIds[i]!;
+    const amount = amounts[i]!;
+    const orc = oracleResults[i]!;
+
+    let ok = true;
+    let reason: DepositBlockReason | undefined;
+
+    if (amount === 0n) {
+      ok = false;
+      reason = "zero-amount";
+    } else if (!orc.isConfigured) {
+      ok = false;
+      reason = "not-configured";
+    } else if (!orc.isDepositAllowed) {
+      ok = false;
+      reason = "deposit-not-allowed";
+    } else if (!orc.isValidCollateral) {
+      ok = false;
+      reason = "invalid-collateral";
+    }
+
+    if (!ok) allItemsOk = false;
+    items.push(
+      reason !== undefined
+        ? { positionId: pid, amount, ok, reason }
+        : { positionId: pid, amount, ok },
+    );
+  }
+
+  // Count how many NEW positions this deposit would add.
+  const uniqueNewPositionIds = new Set<bigint>();
+  for (let i = 0; i < positionIds.length; i++) {
+    const pid = positionIds[i]!;
+    const existingBal = existingBalances[i]!;
+    if (existingBal === 0n) {
+      uniqueNewPositionIds.add(pid);
+    }
+  }
+  const newCount = positionCount + BigInt(uniqueNewPositionIds.size);
+  const wouldExceedMaxPositions = newCount > maxPositions;
+
+  const canDeposit = allItemsOk && !wouldExceedMaxPositions;
+
+  return {
+    canDeposit,
+    items,
+    currentPositionCount: positionCount,
+    maxPositions,
+    wouldExceedMaxPositions,
+  };
+}
+
 export type ReadAccountSnapshot = {
   portfolioValue: bigint;
   collateralValue: bigint;