@varla/sdk 4.0.0 → 4.1.0

package/src/abi/full/VarlaCore.ts

@@ -492,6 +492,17 @@ export const VARLACORE_ABI = [
     "name": "TooManyPositions",
     "type": "error"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      }
+    ],
+    "name": "UnsupportedPositionsToken",
+    "type": "error"
+  },
   {
     "inputs": [],
     "name": "WouldBeUndercollateralized",
@@ -1168,34 +1179,6 @@ export const VARLACORE_ABI = [
     "stateMutability": "nonpayable",
     "type": "function"
   },
-  {
-    "inputs": [
-      {
-        "internalType": "uint256[]",
-        "name": "positionIds",
-        "type": "uint256[]"
-      },
-      {
-        "internalType": "uint256[]",
-        "name": "amounts",
-        "type": "uint256[]"
-      },
-      {
-        "internalType": "uint256",
-        "name": "borrowAmount",
-        "type": "uint256"
-      },
-      {
-        "internalType": "address",
-        "name": "outputAsset",
-        "type": "address"
-      }
-    ],
-    "name": "depositAndBorrow",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
   {
     "inputs": [
       {
@@ -1280,25 +1263,6 @@ export const VARLACORE_ABI = [
     "stateMutability": "view",
     "type": "function"
   },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "user",
-        "type": "address"
-      }
-    ],
-    "name": "getCollateralValue",
-    "outputs": [
-      {
-        "internalType": "uint256",
-        "name": "",
-        "type": "uint256"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
   {
     "inputs": [
       {
@@ -1546,25 +1510,6 @@ export const VARLACORE_ABI = [
     "stateMutability": "view",
     "type": "function"
   },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "user",
-        "type": "address"
-      }
-    ],
-    "name": "getPortfolioValue",
-    "outputs": [
-      {
-        "internalType": "uint256",
-        "name": "",
-        "type": "uint256"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
   {
     "inputs": [
       {
@@ -1924,17 +1869,17 @@ export const VARLACORE_ABI = [
       },
       {
         "internalType": "address",
-        "name": "",
+        "name": "from",
         "type": "address"
       },
       {
         "internalType": "uint256[]",
-        "name": "",
+        "name": "ids",
         "type": "uint256[]"
       },
       {
         "internalType": "uint256[]",
-        "name": "",
+        "name": "values",
         "type": "uint256[]"
       },
       {
@@ -1963,17 +1908,17 @@ export const VARLACORE_ABI = [
       },
       {
         "internalType": "address",
-        "name": "",
+        "name": "from",
         "type": "address"
       },
       {
         "internalType": "uint256",
-        "name": "",
+        "name": "id",
         "type": "uint256"
       },
       {
         "internalType": "uint256",
-        "name": "",
+        "name": "value",
         "type": "uint256"
       },
       {
@@ -2371,6 +2316,29 @@ export const VARLACORE_ABI = [
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256[]",
+        "name": "positionIds",
+        "type": "uint256[]"
+      },
+      {
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
+      },
+      {
+        "internalType": "address",
+        "name": "destination",
+        "type": "address"
+      }
+    ],
+    "name": "withdraw",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {

package/src/abi/full/VarlaLiquidator.ts

@@ -513,7 +513,7 @@ export const VARLALIQUIDATOR_ABI = [
       },
       {
         "internalType": "uint256",
-        "name": "collateralValue",
+        "name": "portfolioValue",
         "type": "uint256"
       },
       {

package/src/actions/core.ts

@@ -23,18 +23,50 @@ export async function prepareCoreDeposit(params: {
   } as any)) as any;
 }
 
+/**
+ * Withdraw deposited ERC1155 collateral from VarlaCore back to a wallet.
+ *
+ * Two call paths:
+ * - **No `recipient`** (default): calls `withdraw(ids, amounts)` — tokens sent to `msg.sender`.
+ * - **With `recipient`**: calls `withdraw(ids, amounts, destination)` — tokens sent to the
+ *   specified address instead of the caller. Useful for Safe / proxy wallets or any flow
+ *   where the signer and the token recipient differ.
+ *
+ * @example
+ * ```ts
+ * // Withdraw to self (default)
+ * const tx = await prepareCoreWithdraw({ publicClient, coreAddress, account, positionIds, amounts });
+ *
+ * // Withdraw to a different address
+ * const tx = await prepareCoreWithdraw({
+ *   publicClient, coreAddress, account,
+ *   positionIds, amounts,
+ *   recipient: "0xAbc...",
+ * });
+ * ```
+ */
 export async function prepareCoreWithdraw(params: {
   publicClient: Pick<PublicClient, "simulateContract">;
   coreAddress: Address;
   account: Address;
   positionIds: readonly bigint[];
   amounts: readonly bigint[];
+  /**
+   * Optional destination address for the withdrawn ERC1155 tokens.
+   *
+   * When provided, calls `withdraw(positionIds, amounts, destination)`.
+   * When omitted, calls `withdraw(positionIds, amounts)` (tokens go to `msg.sender`).
+   */
+  recipient?: Address;
 }): Promise<SimulatedTx> {
   return (await params.publicClient.simulateContract({
     address: params.coreAddress,
     abi: abis.VARLACORE_ABI,
     functionName: "withdraw",
-    args: [params.positionIds, params.amounts],
+    args:
+      params.recipient !== undefined
+        ? [params.positionIds, params.amounts, params.recipient]
+        : [params.positionIds, params.amounts],
     account: params.account,
   } as any)) as any;
 }

package/src/actions/erc1155.ts

@@ -20,3 +20,99 @@ export async function prepareErc1155SetApprovalForAll(params: {
     account: params.account,
   } as any)) as any;
 }
+
+/**
+ * Deposit a single ERC1155 position into VarlaCore by directly calling
+ * `ctf.safeTransferFrom(user, core, id, amount, "")`.
+ *
+ * This triggers VarlaCore's `onERC1155Received` hook which credits the
+ * sender (`from`) with the deposited amount — no prior `setApprovalForAll`
+ * to Core is required since the caller is initiating the transfer themselves.
+ *
+ * Use this as a drop-in alternative to `prepareCoreDeposit` when the user
+ * prefers the ERC1155-push pattern (e.g. in single-token flows or when
+ * building atomic Safe multisend batches where approval is undesirable).
+ *
+ * @example
+ * ```ts
+ * import { prepareCoreDepositViaSafeTransfer } from "@varla/sdk/actions";
+ *
+ * const tx = await prepareCoreDepositViaSafeTransfer({
+ *   publicClient,
+ *   ctfAddress,
+ *   coreAddress,
+ *   account: userAddress,
+ *   positionId: BigInt(posId),
+ *   amount: 100_000_000n, // 100 USDC (6 decimals)
+ * });
+ * await walletClient.writeContract(tx.request);
+ * ```
+ */
+export async function prepareCoreDepositViaSafeTransfer(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  /** Address of the ERC1155 positions token (Polymarket CTF). */
+  ctfAddress: Address;
+  /** Address of VarlaCore (the transfer recipient). */
+  coreAddress: Address;
+  account: Address;
+  positionId: bigint;
+  amount: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.ctfAddress,
+    abi: erc1155Abi,
+    functionName: "safeTransferFrom",
+    args: [params.account, params.coreAddress, params.positionId, params.amount, "0x"],
+    account: params.account,
+  } as any)) as any;
+}
+
+/**
+ * Deposit multiple ERC1155 positions into VarlaCore in a single call by using
+ * `ctf.safeBatchTransferFrom(user, core, ids, amounts, "")`.
+ *
+ * This triggers VarlaCore's `onERC1155BatchReceived` hook which credits the
+ * sender (`from`) with each transferred amount. No prior `setApprovalForAll`
+ * to Core is needed.
+ *
+ * Prefer this over multiple `prepareCoreDepositViaSafeTransfer` calls when
+ * depositing several positions atomically (single tx, lower gas).
+ *
+ * @example
+ * ```ts
+ * import { prepareCoreDepositViaSafeBatchTransfer } from "@varla/sdk/actions";
+ *
+ * const tx = await prepareCoreDepositViaSafeBatchTransfer({
+ *   publicClient,
+ *   ctfAddress,
+ *   coreAddress,
+ *   account: userAddress,
+ *   positionIds: [BigInt(yesId), BigInt(noId)],
+ *   amounts: [50_000_000n, 50_000_000n],
+ * });
+ * await walletClient.writeContract(tx.request);
+ * ```
+ */
+export async function prepareCoreDepositViaSafeBatchTransfer(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  /** Address of the ERC1155 positions token (Polymarket CTF). */
+  ctfAddress: Address;
+  /** Address of VarlaCore (the transfer recipient). */
+  coreAddress: Address;
+  account: Address;
+  positionIds: readonly bigint[];
+  amounts: readonly bigint[];
+}): Promise<SimulatedTx> {
+  if (params.positionIds.length !== params.amounts.length) {
+    throw new Error(
+      `prepareCoreDepositViaSafeBatchTransfer: positionIds.length (${params.positionIds.length}) must equal amounts.length (${params.amounts.length})`,
+    );
+  }
+  return (await params.publicClient.simulateContract({
+    address: params.ctfAddress,
+    abi: erc1155Abi,
+    functionName: "safeBatchTransferFrom",
+    args: [params.account, params.coreAddress, params.positionIds, params.amounts, "0x"],
+    account: params.account,
+  } as any)) as any;
+}

package/src/views/core.ts

@@ -196,6 +196,150 @@ export async function previewCoreDeposit(params: {
   };
 }
 
+// ---------------------------------------------------------------------------
+// Withdraw pre-flight (previewCoreWithdraw)
+// ---------------------------------------------------------------------------
+
+/**
+ * Reason a collateral withdrawal would be rejected for a specific position.
+ *
+ * - `"zero-amount"` — caller passed `amount === 0n`.
+ * - `"insufficient-balance"` — user's deposited balance is below the requested amount.
+ */
+export type WithdrawBlockReason = "zero-amount" | "insufficient-balance";
+
+export type PreviewCoreWithdrawItem = {
+  positionId: bigint;
+  amount: bigint;
+  /** Current deposited balance of the user for this position. */
+  balance: bigint;
+  /** `true` when this position passes the pre-flight balance check. */
+  ok: boolean;
+  /** Present only when `ok === false`. */
+  reason?: WithdrawBlockReason;
+};
+
+export type PreviewCoreWithdraw = {
+  /**
+   * `true` only when every position passes the balance check AND the user either
+   * has no outstanding debt or has sufficient health factor to absorb the withdrawal.
+   *
+   * When `hasDeb === true`, always simulate the on-chain call or check HF separately
+   * before submitting — this preview cannot compute the exact post-withdraw HF
+   * without oracle price data.
+   */
+  canWithdraw: boolean;
+  /** Per-position results aligned to input order. */
+  items: PreviewCoreWithdrawItem[];
+  /** `true` when the user has any outstanding debt. Withdrawing while indebted
+   *  may reduce the health factor below the liquidation threshold. */
+  hasDebt: boolean;
+  /** Current health factor (WAD). `0` when the user has no debt. */
+  healthFactor: bigint;
+};
+
+/**
+ * Pre-flight check that mirrors VarlaCore.withdraw() balance validation.
+ *
+ * Checks (per position):
+ * 1. `amount > 0`
+ * 2. `core.positionBalances(user, id) >= amount`
+ *
+ * Account-level:
+ * - Whether the user currently has debt (`debt > 0`).
+ *
+ * **Important**: this function cannot predict the post-withdraw health factor
+ * without live oracle prices. When `hasDebt === true`, always double-check
+ * the HF with `readHealthFactor` or simulate the transaction before submitting.
+ *
+ * @example
+ * ```ts
+ * import { previewCoreWithdraw } from "@varla/sdk/views";
+ *
+ * const preview = await previewCoreWithdraw({
+ *   core,
+ *   user: "0x...",
+ *   positionIds: [yesId],
+ *   amounts: [50_000_000n],
+ * });
+ *
+ * if (!preview.canWithdraw) {
+ *   for (const item of preview.items) {
+ *     if (!item.ok) console.log(`Position ${item.positionId}: ${item.reason}`);
+ *   }
+ *   if (preview.hasDebt) console.log("User has debt — check HF before withdrawing");
+ * }
+ * ```
+ */
+// wraps: VarlaCore.positionBalances,VarlaCore.getDebt,VarlaCore.getHealthFactor
+export async function previewCoreWithdraw(params: {
+  core: {
+    read: {
+      positionBalances: (args: readonly [Address, bigint]) => Promise<bigint>;
+      getDebt: (args: readonly [Address]) => Promise<bigint>;
+      getHealthFactor: (args: readonly [Address]) => Promise<unknown>;
+    };
+  };
+  user: Address;
+  positionIds: readonly bigint[];
+  amounts: readonly bigint[];
+}): Promise<PreviewCoreWithdraw> {
+  const { core, user, positionIds, amounts } = params;
+
+  if (positionIds.length !== amounts.length) {
+    throw new Error("previewCoreWithdraw: positionIds and amounts must have the same length");
+  }
+
+  // Fetch all balances and account debt in parallel.
+  const [balances, debt, hfRaw] = await Promise.all([
+    Promise.all(positionIds.map((pid) => core.read.positionBalances([user, pid]))),
+    core.read.getDebt([user]),
+    core.read.getHealthFactor([user]),
+  ]);
+
+  // Extract health factor from the tuple returned by VarlaCore.getHealthFactor.
+  const hfAny = hfRaw as any;
+  const healthFactor: bigint =
+    typeof hfAny === "bigint"
+      ? hfAny
+      : typeof hfAny?.healthFactor === "bigint"
+        ? hfAny.healthFactor
+        : (hfAny?.[0] ?? 0n);
+
+  // Per-position checks.
+  const items: PreviewCoreWithdrawItem[] = [];
+  let allItemsOk = true;
+
+  for (let i = 0; i < positionIds.length; i++) {
+    const pid = positionIds[i]!;
+    const amount = amounts[i]!;
+    const balance = balances[i]!;
+
+    let ok = true;
+    let reason: WithdrawBlockReason | undefined;
+
+    if (amount === 0n) {
+      ok = false;
+      reason = "zero-amount";
+    } else if (balance < amount) {
+      ok = false;
+      reason = "insufficient-balance";
+    }
+
+    if (!ok) allItemsOk = false;
+    items.push(
+      reason !== undefined
+        ? { positionId: pid, amount, balance, ok, reason }
+        : { positionId: pid, amount, balance, ok },
+    );
+  }
+
+  const hasDebt = debt > 0n;
+  const canWithdraw = allItemsOk;
+
+  return { canWithdraw, items, hasDebt, healthFactor };
+}
+
 export type ReadAccountSnapshot = {
   portfolioValue: bigint;
   collateralValue: bigint;
@@ -513,12 +657,18 @@ export async function readBorrowerState(params: {
   return { user: params.user, scaledDebt, isBorrower, isLiquidatable };
 }
 
-// wraps: VarlaCore.getPortfolioValue
+// wraps: VarlaCore.getAccountSummary
 export async function readPortfolioValue(params: {
-  core: { read: { getPortfolioValue: (args: readonly [Address]) => Promise<bigint> } };
+  core: {
+    read: {
+      getAccountSummary: (
+        args: readonly [Address],
+      ) => Promise<readonly [bigint, bigint, bigint, bigint, bigint]>;
+    };
+  };
   user: Address;
 }): Promise<ReadPortfolioValue> {
-  const portfolioValue = await params.core.read.getPortfolioValue([params.user]);
+  const [portfolioValue] = await params.core.read.getAccountSummary([params.user]);
   return { user: params.user, portfolioValue };
 }