@varla/sdk 1.11.4 → 1.13.2

package/src/actions/oracleUpdaterRouter.ts

@@ -0,0 +1,233 @@
+// Note: explicit .js extension is required for Node ESM resolution.
+
+import type { Address, Hash, Hex } from "viem";
+import { concat, encodeAbiParameters, encodePacked, keccak256, toHex } from "viem";
+
+import { abis } from "../generated.js";
+
+/**
+ * EIP-712 payload builder for OracleUpdaterRouter.
+ *
+ * Router contract name/version are fixed by the solidity constructor:
+ * - name:    VarlaOracleUpdaterRouter
+ * - version: 1
+ */
+export const ORACLE_UPDATER_ROUTER_EIP712 = {
+  name: "VarlaOracleUpdaterRouter",
+  version: "2",
+} as const;
+
+// ── Nonce-lane helpers (EIP-4337 style) ─────────────────────────────────────
+
+/** Upper 192 bits = lane key, lower 64 bits = sequential counter. */
+export function buildNonce(laneKey: bigint, seq: bigint): bigint {
+  return (laneKey << 64n) | (seq & 0xffffffffffffffffn);
+}
+
+/** Split a combined nonce into { laneKey, seq }. */
+export function splitNonce(nonce: bigint): { laneKey: bigint; seq: bigint } {
+  return {
+    laneKey: nonce >> 64n,
+    seq: nonce & 0xffffffffffffffffn,
+  };
+}
+
+export type OracleUpdaterRouterUpdate = {
+  oracle: Address;
+  chainId: bigint;
+  publisher: Address;
+  nonce: bigint;
+  deadline: bigint;
+  positionIds: readonly bigint[];
+  priceList: readonly bigint[];
+  twapList: readonly bigint[];
+  liquidityList: readonly bigint[];
+};
+
+export const ORACLE_UPDATER_ROUTER_TYPES = {
+  Update: [
+    { name: "oracle", type: "address" },
+    { name: "chainId", type: "uint256" },
+    { name: "publisher", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "positionIdsHash", type: "bytes32" },
+    { name: "priceListHash", type: "bytes32" },
+    { name: "twapListHash", type: "bytes32" },
+    { name: "liquidityListHash", type: "bytes32" },
+  ],
+} as const;
+
+/**
+ * Hardcoded UPDATE_TYPEHASH from the deployed OracleUpdaterRouter contract.
+ *
+ * Computed from:
+ * keccak256("Update(address oracle,uint256 chainId,address publisher,uint256 nonce,uint256 deadline,bytes32 positionIdsHash,bytes32 priceListHash,bytes32 twapListHash,bytes32 liquidityListHash)")
+ *
+ * IMPORTANT: This must match the contract's hardcoded UPDATE_TYPEHASH exactly.
+ * If the contract is redeployed with a different type hash, this must be updated.
+ */
+export const UPDATE_TYPEHASH: Hash =
+  "0xfb5c9ee2f30c92eeb6fe0049d8ba63d98fcbb57cccd2761e2fd7275ac1bd9bd0";
+
+/**
+ * Hardcoded EIP712Domain type hash.
+ * keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
+ */
+const EIP712_DOMAIN_TYPEHASH: Hash =
+  "0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f";
+
+/**
+ * Hash a uint256[] array using Solidity's abi.encodePacked semantics.
+ * Matches: keccak256(abi.encodePacked(uint256[]))
+ */
+function hashU256Array(xs: readonly bigint[]): Hash {
+  if (xs.length === 0) return keccak256(new Uint8Array([]));
+  // abi.encodePacked(uint256[]) is just tight packing of each uint256 as 32 bytes
+  const packed = encodePacked(
+    xs.map(() => "uint256" as const),
+    xs as bigint[],
+  );
+  return keccak256(packed);
+}
+
+/**
+ * Convert an update with dynamic arrays into the typed-data "message" shape expected by the router.
+ */
+export function toOracleUpdaterRouterTypedMessage(u: OracleUpdaterRouterUpdate) {
+  return {
+    oracle: u.oracle,
+    chainId: u.chainId,
+    publisher: u.publisher,
+    nonce: u.nonce,
+    deadline: u.deadline,
+    positionIdsHash: hashU256Array(u.positionIds),
+    priceListHash: hashU256Array(u.priceList),
+    twapListHash: hashU256Array(u.twapList),
+    liquidityListHash: hashU256Array(u.liquidityList),
+  } as const;
+}
+
+/**
+ * Compute the EIP-712 domain separator for the OracleUpdaterRouter.
+ */
+function computeDomainSeparator(chainId: bigint, routerAddress: Address): Hash {
+  return keccak256(
+    encodeAbiParameters(
+      [
+        { type: "bytes32" },
+        { type: "bytes32" },
+        { type: "bytes32" },
+        { type: "uint256" },
+        { type: "address" },
+      ],
+      [
+        EIP712_DOMAIN_TYPEHASH,
+        keccak256(toHex(ORACLE_UPDATER_ROUTER_EIP712.name)),
+        keccak256(toHex(ORACLE_UPDATER_ROUTER_EIP712.version)),
+        chainId,
+        routerAddress,
+      ],
+    ),
+  );
+}
+
+/**
+ * Compute the struct hash for an Update using the contract's exact UPDATE_TYPEHASH.
+ * This bypasses viem's automatic type hash computation to ensure exact match with the contract.
+ */
+function computeStructHash(update: OracleUpdaterRouterUpdate): Hash {
+  const msg = toOracleUpdaterRouterTypedMessage(update);
+
+  return keccak256(
+    encodeAbiParameters(
+      [
+        { type: "bytes32" }, // UPDATE_TYPEHASH
+        { type: "address" }, // oracle
+        { type: "uint256" }, // chainId
+        { type: "address" }, // publisher
+        { type: "uint256" }, // nonce
+        { type: "uint256" }, // deadline
+        { type: "bytes32" }, // positionIdsHash
+        { type: "bytes32" }, // priceListHash
+        { type: "bytes32" }, // twapListHash
+        { type: "bytes32" }, // liquidityListHash
+      ],
+      [
+        UPDATE_TYPEHASH,
+        msg.oracle,
+        msg.chainId,
+        msg.publisher,
+        msg.nonce,
+        msg.deadline,
+        msg.positionIdsHash,
+        msg.priceListHash,
+        msg.twapListHash,
+        msg.liquidityListHash,
+      ],
+    ),
+  );
+}
+
+/**
+ * Compute the EIP-712 digest that should be signed.
+ * This manually computes the digest to ensure exact match with the contract's hashUpdate().
+ */
+export function computeOracleUpdaterDigest(params: {
+  routerAddress: Address;
+  update: OracleUpdaterRouterUpdate;
+}): Hash {
+  const domainSeparator = computeDomainSeparator(params.update.chainId, params.routerAddress);
+  const structHash = computeStructHash(params.update);
+
+  // EIP-712: "\x19\x01" ++ domainSeparator ++ structHash
+  return keccak256(concat(["0x1901", domainSeparator, structHash]));
+}
+
+export async function signOracleUpdaterRouterUpdate(params: {
+  walletClient: {
+    signMessage: (args: { message: { raw: Hex } }) => Promise<Hash>;
+  };
+  routerAddress: Address;
+  update: OracleUpdaterRouterUpdate;
+}): Promise<Hash> {
+  // Manually compute the EIP-712 digest to ensure exact match with contract
+  const digest = computeOracleUpdaterDigest({
+    routerAddress: params.routerAddress,
+    update: params.update,
+  });
+
+  // Sign the raw digest (not a personal_sign, just the raw hash)
+  return params.walletClient.signMessage({
+    message: { raw: digest },
+  });
+}
+
+export async function prepareOracleUpdaterRouterUpdatePricesWithSig(params: {
+  publicClient: { simulateContract: (args: any) => Promise<any> };
+  routerAddress: Address;
+  account: Address;
+  update: OracleUpdaterRouterUpdate;
+  signature: Hash;
+}): Promise<any> {
+  return await params.publicClient.simulateContract({
+    address: params.routerAddress,
+    abi: abis.ORACLEUPDATERROUTER_ABI,
+    functionName: "updatePricesWithSig",
+    args: [
+      {
+        oracle: params.update.oracle,
+        chainId: params.update.chainId,
+        publisher: params.update.publisher,
+        nonce: params.update.nonce,
+        deadline: params.update.deadline,
+        positionIds: params.update.positionIds,
+        priceList: params.update.priceList,
+        twapList: params.update.twapList,
+        liquidityList: params.update.liquidityList,
+      },
+      params.signature,
+    ],
+    account: params.account,
+  });
+}

package/src/actions/pool.ts

@@ -0,0 +1,76 @@
+// Note: explicit .js extension is required for Node ESM resolution.
+
+import type { Address, PublicClient } from "viem";
+
+import { abis } from "../generated.js";
+import type { SimulatedTx } from "./oracle.js";
+
+// ---------------------------------------------------------------------------
+// ERC4626 (VarlaPool) write helpers
+// ---------------------------------------------------------------------------
+
+export async function preparePoolDeposit(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  poolAddress: Address;
+  account: Address;
+  assets: bigint;
+  receiver: Address;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.poolAddress,
+    abi: abis.VARLAPOOL_ABI,
+    functionName: "deposit",
+    args: [params.assets, params.receiver],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function preparePoolMint(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  poolAddress: Address;
+  account: Address;
+  shares: bigint;
+  receiver: Address;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.poolAddress,
+    abi: abis.VARLAPOOL_ABI,
+    functionName: "mint",
+    args: [params.shares, params.receiver],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function preparePoolWithdraw(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  poolAddress: Address;
+  account: Address;
+  assets: bigint;
+  receiver: Address;
+  owner: Address;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.poolAddress,
+    abi: abis.VARLAPOOL_ABI,
+    functionName: "withdraw",
+    args: [params.assets, params.receiver, params.owner],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function preparePoolRedeem(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  poolAddress: Address;
+  account: Address;
+  shares: bigint;
+  receiver: Address;
+  owner: Address;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.poolAddress,
+    abi: abis.VARLAPOOL_ABI,
+    functionName: "redeem",
+    args: [params.shares, params.receiver, params.owner],
+    account: params.account,
+  } as any)) as any;
+}

package/src/actions/rbac.ts

@@ -0,0 +1,72 @@
+// Note: explicit .js extension is required for Node ESM resolution.
+
+import type { Address, Hex } from "viem";
+
+// ---------------------------------------------------------------------------
+// Common signatures (DevEx)
+// ---------------------------------------------------------------------------
+
+/**
+ * ABI signatures for commonly preflighted RBAC targets.
+ *
+ * Use with `selectorFromSignature(sig)`.
+ */
+export const ORACLE_SIGS = {
+  configurePositionsBatch:
+    "configurePositionsBatch(uint256[],uint8[],bytes32[],uint256[])" as const,
+  configureOppositePositions: "configureOppositePositions(uint256,uint256)" as const,
+  configureNegRiskPositionsBatch: "configureNegRiskPositionsBatch(uint256[],bytes32)" as const,
+  updatePrices: "updatePrices(uint256[],uint256[],uint256[],uint256[])" as const,
+} as const;
+
+/**
+ * Minimal AccessManager interface needed for RBAC preflight.
+ */
+export type AccessManagerCanCallLike = {
+  read: {
+    canCall: (args: readonly [Address, Address, Hex]) => Promise<unknown>;
+  };
+};
+
+export type CanCallResult = {
+  immediate: boolean;
+  delay: bigint;
+};
+
+// wraps: AccessManager.canCall
+export async function readCanCall(params: {
+  accessManager: AccessManagerCanCallLike;
+  caller: Address;
+  target: Address;
+  selector: Hex;
+}): Promise<CanCallResult> {
+  const raw = await params.accessManager.read.canCall([
+    params.caller,
+    params.target,
+    params.selector,
+  ]);
+  const r: any = raw as any;
+  const immediate = r.immediate ?? r[0];
+  const delayRaw = r.delay ?? r[1];
+  const delay = typeof delayRaw === "bigint" ? delayRaw : BigInt(delayRaw);
+
+  if (typeof immediate !== "boolean" || typeof delay !== "bigint") {
+    throw new Error("Unexpected canCall() return shape");
+  }
+  return { immediate, delay };
+}
+
+/**
+ * Convenience preflight for UIs/backends: throws if the call is not immediately permitted.
+ */
+export async function assertCanCallImmediate(params: {
+  accessManager: AccessManagerCanCallLike;
+  caller: Address;
+  target: Address;
+  selector: Hex;
+}): Promise<void> {
+  const r = await readCanCall(params);
+  if (!r.immediate) {
+    throw new Error(`AccessManager.canCall denied or delayed (delay=${r.delay})`);
+  }
+}

package/src/actions/tx.ts

@@ -0,0 +1,16 @@
+// Note: explicit .js extension is required for Node ESM resolution.
+
+import type { Hash, WalletClient } from "viem";
+
+/**
+ * Thin wrapper over `walletClient.writeContract`.
+ *
+ * This is intentionally minimal; callers are expected to call `simulateContract`
+ * first (via SDK `prepare*` helpers) and pass the returned `request` here.
+ */
+export async function sendTx(params: {
+  walletClient: Pick<WalletClient, "writeContract">;
+  request: unknown;
+}): Promise<Hash> {
+  return (await params.walletClient.writeContract(params.request as any)) as Hash;
+}

package/src/actions/utils.ts

@@ -0,0 +1,15 @@
+// Note: explicit .js extension is required for Node ESM resolution.
+
+import type { Hex } from "viem";
+import { keccak256, toBytes } from "viem";
+
+/**
+ * Compute a 4-byte function selector from a Solidity function signature.
+ *
+ * Example:
+ * - "borrow(uint256)" -> 0x....
+ */
+export function selectorFromSignature(signature: string): Hex {
+  const hash = keccak256(toBytes(signature));
+  return `0x${hash.slice(2, 10)}` as Hex;
+}

package/src/addresses/README.md

@@ -0,0 +1,17 @@
+This folder is generated.
+
+Run from repo root:
+
+```bash
+bun run gen:sdk
+```
+
+(Legacy alias: `bun run gen:protocol`)
+
+Or run from the SDK package:
+
+```bash
+cd packages/sdk
+bun run gen
+```
+

package/src/addresses/bsc.json

@@ -0,0 +1,16 @@
+{
+  "chain": "bsc",
+  "generatedAt": "",
+  "deploymentsDir": "bsc",
+  "contracts": {
+    "VarlaAccessManager": "0xd1FbB7E03EAe69314bc1A8412da464844d31208D",
+    "VarlaOracle": "0x9F4eFE380f6A1c124056ABC64fAe6c18d9a717ee",
+    "VarlaCore": "0x765CFa9BFD553B81985cc614559F5F4Ce8B617e0",
+    "VarlaPool": "0x4a7fEDCc9365A98Fc482358f08b132f82fEE2eCb",
+    "OracleUpdaterRouter": "0x58fbf3be3d0CbBed091ad6940d4dbF7462bEb6aA",
+    "VarlaLiquidator": "0xf53eBDf041EEa32794d883CA9C4380775abd592A",
+    "VarlaMergeLiquidator": "0x651e48875e07B66ec886E68249449A5F795B545d",
+    "VarlaConvertLiquidator": "0xd265863a9A4860E73E4d9b0EE2783A3e379b53Ca",
+    "OpinionCtfExecutionEngineAdapter": "0x9E56d02E50ba99943aB6A3f6Bd466E7954674A31"
+  }
+}

package/src/addresses/bsc.ts

@@ -0,0 +1,15 @@
+// Auto-generated from varla-protocol deployments/bsc
+import type { AddressBook } from "../types";
+
+export const bsc: AddressBook = {
+  accessManager: "0xd1FbB7E03EAe69314bc1A8412da464844d31208D",
+  oracle: "0x9F4eFE380f6A1c124056ABC64fAe6c18d9a717ee",
+  core: "0x765CFa9BFD553B81985cc614559F5F4Ce8B617e0",
+  pool: "0x4a7fEDCc9365A98Fc482358f08b132f82fEE2eCb",
+  oracleUpdaterRouter: "0x58fbf3be3d0CbBed091ad6940d4dbF7462bEb6aA",
+  liquidator: "0xf53eBDf041EEa32794d883CA9C4380775abd592A",
+  mergeLiquidator: "0x651e48875e07B66ec886E68249449A5F795B545d",
+  convertLiquidator: "0xd265863a9A4860E73E4d9b0EE2783A3e379b53Ca",
+  opinionCtfExecutionEngineAdapter: "0x9E56d02E50ba99943aB6A3f6Bd466E7954674A31",
+};
+

package/src/addresses/index.ts

@@ -0,0 +1,6 @@
+// Auto-generated by varla-protocol/scripts/export-addressbook.ts
+// Do not edit manually.
+
+export * from "./polygon.js";
+export * from "./bsc.js";
+

package/src/addresses/polygon.json

@@ -0,0 +1,16 @@
+{
+  "chain": "polygon",
+  "generatedAt": "",
+  "deploymentsDir": "polygon",
+  "contracts": {
+    "VarlaAccessManager": "0x8D0Afc20555F3B0042A542d4843F8d03B85e89Ad",
+    "VarlaOracle": "0x196519791b96051104dE06aeA887D9cC8D5e4A15",
+    "VarlaCore": "0x0E611985132Ee9C13fe8e9ADC9cB094a250FBb82",
+    "VarlaPool": "0x62DB666faC25a2280917CDd59A9370E66A2ea533",
+    "OracleUpdaterRouter": "0xa9Bf7DcaA9b40950aC645D61f334155a8F00e734",
+    "VarlaLiquidator": "0x0BcE7dc799C8d7011ea48B9D4Abd2657D6d9e2E9",
+    "VarlaMergeLiquidator": "0x991B90cd8CEC1E5526fF04b01811250204A563ab",
+    "VarlaConvertLiquidator": "0x4554316C874ed1Dcb128B34cC5204Ae4717fAa9B",
+    "PolymarketCtfAdapter": "0x38aF55797a6F31bd9313d88b3D0Bb81a6a2007E3"
+  }
+}

package/src/addresses/polygon.ts

@@ -0,0 +1,15 @@
+// Auto-generated from varla-protocol deployments/polygon
+import type { AddressBook } from "../types";
+
+export const polygon: AddressBook = {
+  accessManager: "0x8D0Afc20555F3B0042A542d4843F8d03B85e89Ad",
+  oracle: "0x196519791b96051104dE06aeA887D9cC8D5e4A15",
+  core: "0x0E611985132Ee9C13fe8e9ADC9cB094a250FBb82",
+  pool: "0x62DB666faC25a2280917CDd59A9370E66A2ea533",
+  oracleUpdaterRouter: "0xa9Bf7DcaA9b40950aC645D61f334155a8F00e734",
+  liquidator: "0x0BcE7dc799C8d7011ea48B9D4Abd2657D6d9e2E9",
+  mergeLiquidator: "0x991B90cd8CEC1E5526fF04b01811250204A563ab",
+  convertLiquidator: "0x4554316C874ed1Dcb128B34cC5204Ae4717fAa9B",
+  polymarketCtfAdapter: "0x38aF55797a6F31bd9313d88b3D0Bb81a6a2007E3",
+};
+

package/src/addresses.ts

@@ -0,0 +1,2 @@
+// Note: explicit .js extension is required for Node ESM resolution.
+export * from "./addresses/index.js";

package/src/batch.ts

@@ -0,0 +1,55 @@
+// Note: explicit .js extension is required for Node ESM resolution.
+
+import type { Abi, Address, PublicClient } from "viem";
+
+export type MulticallChunkOptions = {
+  /** Number of calls per multicall batch. */
+  chunkSize?: number;
+};
+
+/**
+ * Small utility to chunk an array.
+ */
+export function chunk<T>(items: readonly T[], chunkSize: number): T[][] {
+  if (chunkSize <= 0) throw new Error(`chunkSize must be > 0 (got ${chunkSize})`);
+  const out: T[][] = [];
+  for (let i = 0; i < items.length; i += chunkSize) out.push(items.slice(i, i + chunkSize));
+  return out;
+}
+
+/**
+ * Executes `client.multicall` in chunks.
+ *
+ * - Keeps requests bounded for public RPC providers.
+ * - Preserves order.
+ */
+export async function multicallChunks<_TAbi extends Abi>(params: {
+  client: PublicClient;
+  // Keep this type explicit and non-generic.
+  // viem's `PublicClient` is generic, and extracting `multicall`'s parameter types
+  // from an un-parameterized PublicClient can degrade to `unknown[]`.
+  contracts: readonly {
+    address: Address;
+    abi: Abi;
+    functionName: string;
+    args?: readonly unknown[] | undefined;
+  }[];
+  chunkSize?: number;
+}): Promise<Awaited<ReturnType<PublicClient["multicall"]>>> {
+  const { client } = params;
+  const chunkSize = params.chunkSize ?? 128;
+  const calls = params.contracts;
+
+  if (calls.length === 0) return [] as any;
+
+  // Note: we avoid a generic chunk() here because TS can sometimes lose the
+  // `client.multicall` contract-call type across the generic boundary.
+  const out: any[] = [];
+  for (let i = 0; i < calls.length; i += chunkSize) {
+    const slice = calls.slice(i, i + chunkSize);
+    const res = await client.multicall({ contracts: slice as any });
+    out.push(...res);
+  }
+
+  return out as any;
+}