@varla/sdk 1.11.4 → 1.14.0

package/src/abi.ts

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

package/src/actions/admin.ts

@@ -0,0 +1,357 @@
+// 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";
+
+// ---------------------------------------------------------------------------
+// Admin / governance write helpers
+// ---------------------------------------------------------------------------
+
+// -----------------
+// Core admin
+// -----------------
+
+export async function prepareCoreSetDefaultLtvConfig(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  conservative: bigint;
+  moderate: bigint;
+  risk: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "setDefaultLtvConfig",
+    args: [params.conservative, params.moderate, params.risk],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareCoreSetLiquidationConfig(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  targetHealthFactor: bigint;
+  healthFactorForMaxBonus: bigint;
+  liquidationBonusFactorBps: bigint;
+  dustThreshold: bigint;
+  collateralDustThreshold: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "setLiquidationConfig",
+    args: [
+      params.targetHealthFactor,
+      params.healthFactorForMaxBonus,
+      params.liquidationBonusFactorBps,
+      params.dustThreshold,
+      params.collateralDustThreshold,
+    ],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareCoreSetTierLiquidationConfig(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  tier: number;
+  maxLiquidationBonusBps: bigint;
+  liquidationFeeBps: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "setTierLiquidationConfig",
+    args: [params.tier, params.maxLiquidationBonusBps, params.liquidationFeeBps],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareCoreSetMaxPositions(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  maxPositions: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "setMaxPositions",
+    args: [params.maxPositions],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareCoreSetMaxPositionsBounds(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  min: bigint;
+  max: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "setMaxPositionsBounds",
+    args: [params.min, params.max],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareCoreSetOracle(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  oracle: Address;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "setOracle",
+    args: [params.oracle],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareCoreSetPositionLtvOverride(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  positionId: bigint;
+  ltvWad: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "setPositionLtvOverride",
+    args: [params.positionId, params.ltvWad],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareCoreClearPositionLtvOverride(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  positionId: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "clearPositionLtvOverride",
+    args: [params.positionId],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareCoreSetPositionLiquidationConfigOverride(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  positionId: bigint;
+  maxLiquidationBonusBps: bigint;
+  liquidationFeeBps: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "setPositionLiquidationConfigOverride",
+    args: [params.positionId, params.maxLiquidationBonusBps, params.liquidationFeeBps],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareCoreClearPositionLiquidationConfigOverride(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  positionId: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "clearPositionLiquidationConfigOverride",
+    args: [params.positionId],
+    account: params.account,
+  } as any)) as any;
+}
+
+// -----------------
+// Pool admin
+// -----------------
+
+export async function preparePoolSetDepositCap(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  poolAddress: Address;
+  account: Address;
+  cap: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.poolAddress,
+    abi: abis.VARLAPOOL_ABI,
+    functionName: "setDepositCap",
+    args: [params.cap],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function preparePoolSetBorrowCap(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  poolAddress: Address;
+  account: Address;
+  cap: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.poolAddress,
+    abi: abis.VARLAPOOL_ABI,
+    functionName: "setBorrowCap",
+    args: [params.cap],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function preparePoolWithdrawReserve(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  poolAddress: Address;
+  account: Address;
+  to: Address;
+  amount: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.poolAddress,
+    abi: abis.VARLAPOOL_ABI,
+    functionName: "withdrawReserve",
+    args: [params.to, params.amount],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function preparePoolSetInterestRateStrategy(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  poolAddress: Address;
+  account: Address;
+  strategy: Address;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.poolAddress,
+    abi: abis.VARLAPOOL_ABI,
+    functionName: "setInterestRateStrategy",
+    args: [params.strategy],
+    account: params.account,
+  } as any)) as any;
+}
+
+// -----------------
+// Oracle admin
+// -----------------
+
+export async function prepareOracleSetMaxStaleness(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  oracleAddress: Address;
+  account: Address;
+  maxStaleness: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.oracleAddress,
+    abi: abis.VARLAORACLE_ABI,
+    functionName: "setMaxStaleness",
+    args: [params.maxStaleness],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareOracleSetLiquidationGracePeriod(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  oracleAddress: Address;
+  account: Address;
+  gracePeriod: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.oracleAddress,
+    abi: abis.VARLAORACLE_ABI,
+    functionName: "setLiquidationGracePeriod",
+    args: [params.gracePeriod],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareOracleSetDefaultEarlyClosureWindow(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  oracleAddress: Address;
+  account: Address;
+  window: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.oracleAddress,
+    abi: abis.VARLAORACLE_ABI,
+    functionName: "setDefaultEarlyClosureWindow",
+    args: [params.window],
+    account: params.account,
+  } as any)) as any;
+}
+
+// -----------------
+// InterestRateStrategy admin
+// -----------------
+
+export async function prepareStrategySetPool(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  strategyAddress: Address;
+  account: Address;
+  pool: Address;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.strategyAddress,
+    abi: abis.VARLAINTERESTRATESTRATEGY_ABI,
+    functionName: "setPool",
+    args: [params.pool],
+    account: params.account,
+  } as any)) as any;
+}
+
+export type StrategyRateParams = {
+  optimalUsageRatio: number;
+  baseVariableBorrowRate: number;
+  variableRateSlope1: number;
+  variableRateSlope2: number;
+};
+
+export async function prepareStrategySetRateParams(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  strategyAddress: Address;
+  account: Address;
+  params: StrategyRateParams;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.strategyAddress,
+    abi: abis.VARLAINTERESTRATESTRATEGY_ABI,
+    functionName: "setRateParams",
+    args: [params.params],
+    account: params.account,
+  } as any)) as any;
+}
+
+// -----------------
+// OracleUpdaterRouter admin
+// -----------------
+
+export async function prepareOracleUpdaterRouterSetPublisher(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  routerAddress: Address;
+  account: Address;
+  publisher: Address;
+  allowed: boolean;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.routerAddress,
+    abi: abis.ORACLEUPDATERROUTER_ABI,
+    functionName: "setPublisher",
+    args: [params.publisher, params.allowed],
+    account: params.account,
+  } as any)) as any;
+}

package/src/actions/core.ts

@@ -0,0 +1,68 @@
+// 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";
+
+export async function prepareCoreDeposit(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  positionIds: readonly bigint[];
+  amounts: readonly bigint[];
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "deposit",
+    args: [params.positionIds, params.amounts],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareCoreWithdraw(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  positionIds: readonly bigint[];
+  amounts: readonly bigint[];
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "withdraw",
+    args: [params.positionIds, params.amounts],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareCoreBorrow(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  amount: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "borrow",
+    args: [params.amount],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareCoreRepay(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  coreAddress: Address;
+  account: Address;
+  amount: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.coreAddress,
+    abi: abis.VARLACORE_ABI,
+    functionName: "repay",
+    args: [params.amount],
+    account: params.account,
+  } as any)) as any;
+}

package/src/actions/erc1155.ts

@@ -0,0 +1,22 @@
+// Note: explicit .js extension is required for Node ESM resolution.
+
+import type { Address, PublicClient } from "viem";
+import { erc1155Abi } from "viem";
+
+import type { SimulatedTx } from "./oracle.js";
+
+export async function prepareErc1155SetApprovalForAll(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  tokenAddress: Address;
+  account: Address;
+  operator: Address;
+  approved: boolean;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.tokenAddress,
+    abi: erc1155Abi,
+    functionName: "setApprovalForAll",
+    args: [params.operator, params.approved],
+    account: params.account,
+  } as any)) as any;
+}

package/src/actions/erc20.ts

@@ -0,0 +1,22 @@
+// Note: explicit .js extension is required for Node ESM resolution.
+
+import type { Address, PublicClient } from "viem";
+import { erc20Abi } from "viem";
+
+import type { SimulatedTx } from "./oracle.js";
+
+export async function prepareErc20Approve(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  tokenAddress: Address;
+  account: Address;
+  spender: Address;
+  amount: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.tokenAddress,
+    abi: erc20Abi,
+    functionName: "approve",
+    args: [params.spender, params.amount],
+    account: params.account,
+  } as any)) as any;
+}

package/src/actions/index.ts

@@ -0,0 +1,13 @@
+// Note: explicit .js extension is required for Node ESM resolution.
+
+export * from "./admin.js";
+export * from "./core.js";
+export * from "./erc20.js";
+export * from "./erc1155.js";
+export * from "./liquidator.js";
+export * from "./oracle.js";
+export * from "./oracleUpdaterRouter.js";
+export * from "./pool.js";
+export * from "./rbac.js";
+export * from "./tx.js";
+export * from "./utils.js";

package/src/actions/liquidator.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";
+
+// ---------------------------------------------------------------------------
+// Liquidator (bot flows) write helpers
+// ---------------------------------------------------------------------------
+
+export async function prepareLiquidatorLiquidate(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  liquidatorAddress: Address;
+  account: Address;
+  user: Address;
+  positionId: bigint;
+  debtToCover: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.liquidatorAddress,
+    abi: abis.VARLALIQUIDATOR_ABI,
+    functionName: "liquidate",
+    args: [params.user, params.positionId, params.debtToCover],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareLiquidatorLiquidateMulti(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  liquidatorAddress: Address;
+  account: Address;
+  user: Address;
+  positionIds: readonly bigint[];
+  debtToCover: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.liquidatorAddress,
+    abi: abis.VARLALIQUIDATOR_ABI,
+    functionName: "liquidateMulti",
+    args: [params.user, params.positionIds, params.debtToCover],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareLiquidatorLiquidateBadDebt(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  liquidatorAddress: Address;
+  account: Address;
+  user: Address;
+  maxRepayAmount: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.liquidatorAddress,
+    abi: abis.VARLALIQUIDATOR_ABI,
+    functionName: "liquidateBadDebt",
+    args: [params.user, params.maxRepayAmount],
+    account: params.account,
+  } as any)) as any;
+}
+
+export async function prepareLiquidatorResolveBadDebtWithReserve(params: {
+  publicClient: Pick<PublicClient, "simulateContract">;
+  liquidatorAddress: Address;
+  account: Address;
+  user: Address;
+  expectedScaledDebt: bigint;
+}): Promise<SimulatedTx> {
+  return (await params.publicClient.simulateContract({
+    address: params.liquidatorAddress,
+    abi: abis.VARLALIQUIDATOR_ABI,
+    functionName: "resolveBadDebtWithReserve",
+    args: [params.user, params.expectedScaledDebt],
+    account: params.account,
+  } as any)) as any;
+}