@varla/sdk 2.10.0 → 2.11.0

package/src/abi/subsets/VarlaOracle.registry.ts

@@ -138,6 +138,27 @@ export const VARLAORACLE_ABI_REGISTRY = [
     "name": "InvalidLiquidationGracePeriod",
     "type": "error"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "uint8",
+        "name": "tier",
+        "type": "uint8"
+      },
+      {
+        "internalType": "uint256",
+        "name": "gracePeriod",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "decayPeriod",
+        "type": "uint256"
+      }
+    ],
+    "name": "InvalidLowLiquidityConfig",
+    "type": "error"
+  },
   {
     "inputs": [
       {
@@ -338,6 +359,68 @@ export const VARLAORACLE_ABI_REGISTRY = [
     "name": "LiquidationGracePeriodUpdated",
     "type": "event"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint8",
+        "name": "tier",
+        "type": "uint8"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "oldGracePeriod",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "oldDecayPeriod",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "newGracePeriod",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "newDecayPeriod",
+        "type": "uint256"
+      }
+    ],
+    "name": "LowLiquidityConfigUpdated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "positionId",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "oldLowLiquiditySince",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "newLowLiquiditySince",
+        "type": "uint256"
+      }
+    ],
+    "name": "LowLiquiditySinceUpdated",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [

package/src/index.ts

@@ -13,6 +13,8 @@ export * from "./events/index.js";
 export * from "./format.js";
 // Chain/platform metadata (UI-friendly).
 export * from "./meta.js";
+// Safe MultiSend encoding (proxy wallet support).
+export * from "./safe.js";
 export * from "./types.js";
 // Higher-level read helpers (views/facades).
 export * from "./views/index.js";

package/src/safe.ts

@@ -0,0 +1,226 @@
+// Note: explicit .js extension is required for Node ESM resolution.
+
+import { type Address, concat, encodeFunctionData, encodePacked, type Hex } from "viem";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Constants
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Canonical Safe MultiSend contract address.
+ * Deployed at the same address on all EVM chains (Safe v1.3.0+ deterministic deployment).
+ *
+ * @see https://github.com/safe-global/safe-deployments
+ */
+export const SAFE_MULTISEND_ADDRESS: Address = "0x38869bf66a61cF6bDB996A6aE40D5853Fd43B526";
+
+/**
+ * Canonical Safe MultiSend "call only" contract address.
+ * Same as MultiSend but restricted to CALL operations (no DELEGATECALL).
+ */
+export const SAFE_MULTISEND_CALL_ONLY_ADDRESS: Address =
+  "0x9641d764fc13c8B624c04430C7356C1C7C8102e2";
+
+/**
+ * ABI for the Safe MultiSend contract.
+ */
+const MULTISEND_ABI = [
+  {
+    name: "multiSend",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [{ name: "transactions", type: "bytes" }],
+    outputs: [],
+  },
+] as const;
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Operation type for Safe transactions.
+ * - `0` = CALL (standard external call)
+ * - `1` = DELEGATECALL (execute in Safe context)
+ */
+export type SafeOperation = 0 | 1;
+
+/**
+ * A single transaction in a Safe MultiSend batch.
+ */
+export type SafeMultiSendTx = {
+  /** Target contract address. */
+  to: Address;
+  /** ETH value to send (default: 0). */
+  value?: bigint;
+  /** Encoded calldata. */
+  data: Hex;
+  /** Operation type (default: 0 = CALL). */
+  operation?: SafeOperation;
+};
+
+/**
+ * Input for building a Safe MultiSend batch.
+ * Accepts raw `SafeMultiSendTx` objects or `prepare*()` simulation results.
+ *
+ * The `request` property from `simulateContract` contains `{ to, data, value }` —
+ * exactly what we need.
+ */
+export type SafeMultiSendInput =
+  | SafeMultiSendTx
+  | { request: { to: Address; data: Hex; value?: bigint } };
+
+/**
+ * Result of encoding a Safe MultiSend batch.
+ */
+export type SafeMultiSendResult = {
+  /** Address of the MultiSend contract to call. */
+  to: Address;
+  /** Encoded `multiSend(bytes)` calldata. */
+  data: Hex;
+  /** Total ETH value across all transactions. */
+  value: bigint;
+  /** Number of transactions in the batch. */
+  count: number;
+};
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════════════════════════
+
+function normalizeInput(input: SafeMultiSendInput): SafeMultiSendTx {
+  if ("request" in input) {
+    return {
+      to: input.request.to,
+      data: input.request.data,
+      value: input.request.value ?? 0n,
+      operation: 0,
+    };
+  }
+  return input;
+}
+
+/**
+ * Encode a single transaction into the Safe MultiSend packed format.
+ *
+ * Format (tightly packed, no padding):
+ * ```
+ * uint8   operation    (1 byte)
+ * address to           (20 bytes)
+ * uint256 value        (32 bytes)
+ * uint256 dataLength   (32 bytes)
+ * bytes   data         (variable)
+ * ```
+ *
+ * @see https://github.com/safe-global/safe-smart-account/blob/main/contracts/libraries/MultiSend.sol
+ */
+function encodeSingleTx(tx: SafeMultiSendTx): Hex {
+  const op = tx.operation ?? 0;
+  const value = tx.value ?? 0n;
+  const dataBytes = tx.data as Hex;
+  // Strip "0x" prefix for length calculation
+  const dataLen = (dataBytes.length - 2) / 2;
+
+  return encodePacked(
+    ["uint8", "address", "uint256", "uint256", "bytes"],
+    [op, tx.to, value, BigInt(dataLen), dataBytes],
+  );
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Public API
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Encode multiple transactions into a Safe MultiSend batch.
+ *
+ * Accepts either raw `SafeMultiSendTx` objects or the result of SDK `prepare*()`
+ * helpers (which return `{ request: { to, data, value } }`).
+ *
+ * Returns the encoded `multiSend(bytes)` calldata ready to be submitted to
+ * a Gnosis Safe via `execTransaction` or Safe SDK.
+ *
+ * @example
+ * ```ts
+ * import { encodeSafeMultiSend } from "@varla/sdk/safe";
+ * import * as actions from "@varla/sdk/actions";
+ *
+ * const approve = await actions.prepareErc1155SetApprovalForAll({ ... });
+ * const deposit = await actions.prepareCoreDeposit({ account: safeAddress, ... });
+ * const borrow  = await actions.prepareCoreBorrow({ account: safeAddress, ... });
+ *
+ * const batch = encodeSafeMultiSend([approve, deposit, borrow]);
+ * // batch.to   → MultiSend contract address
+ * // batch.data → encoded multiSend(bytes) calldata
+ * // batch.value → total ETH value
+ *
+ * // Submit via Safe SDK:
+ * // safeSdk.createTransaction({ safeTransactionData: {
+ * //   to: batch.to,
+ * //   data: batch.data,
+ * //   value: batch.value.toString(),
+ * //   operation: 1, // DELEGATECALL to MultiSend
+ * // }});
+ * ```
+ *
+ * @param inputs - Array of transactions (raw or from `prepare*()` results).
+ * @param options - Optional: override MultiSend contract address.
+ * @returns Encoded batch ready for Safe submission.
+ * @throws If inputs array is empty.
+ */
+export function encodeSafeMultiSend(
+  inputs: readonly SafeMultiSendInput[],
+  options?: {
+    /** Override the MultiSend contract address. */
+    multiSendAddress?: Address;
+  },
+): SafeMultiSendResult {
+  if (inputs.length === 0) throw new Error("encodeSafeMultiSend: inputs must not be empty");
+
+  const txs = inputs.map(normalizeInput);
+
+  // If only one transaction, return it directly (no need for MultiSend wrapper).
+  if (txs.length === 1) {
+    const tx = txs[0]!;
+    return {
+      to: tx.to,
+      data: tx.data,
+      value: tx.value ?? 0n,
+      count: 1,
+    };
+  }
+
+  // Pack all transactions
+  const packed = txs.map(encodeSingleTx);
+  const packedData = concat(packed);
+
+  // Encode the multiSend(bytes) call
+  const multiSendCalldata = encodeFunctionData({
+    abi: MULTISEND_ABI,
+    functionName: "multiSend",
+    args: [packedData],
+  });
+
+  const totalValue = txs.reduce((sum, tx) => sum + (tx.value ?? 0n), 0n);
+
+  return {
+    to: options?.multiSendAddress ?? SAFE_MULTISEND_ADDRESS,
+    data: multiSendCalldata,
+    value: totalValue,
+    count: txs.length,
+  };
+}
+
+/**
+ * Convenience: encode a Safe MultiSend batch using the "call only" MultiSend
+ * contract (no DELEGATECALL allowed in sub-transactions).
+ *
+ * This is safer for use cases where the batch should only perform external calls.
+ */
+export function encodeSafeMultiSendCallOnly(
+  inputs: readonly SafeMultiSendInput[],
+): SafeMultiSendResult {
+  return encodeSafeMultiSend(inputs, {
+    multiSendAddress: SAFE_MULTISEND_CALL_ONLY_ADDRESS,
+  });
+}