HypurrFi Markets Agent Reference

# JavaScript / TypeScript
npm install ethers
# or
npm install viem

# Solidity (Foundry)
forge install euler-xyz/euler-interfaces

# Solidity (Hardhat)
npm install @euler-xyz/euler-interfaces

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider("YOUR_RPC_URL");
const signer = await provider.getSigner();

const vaultAddress = "0x..."; // target vault
const vaultABI = [...]; // from euler-interfaces

const vault = new ethers.Contract(vaultAddress, vaultABI, signer);

async function deposit(vaultAddress: string, amount: bigint) {
  const vault = new ethers.Contract(vaultAddress, vaultABI, signer);
  const token = new ethers.Contract(assetAddress, erc20ABI, signer);

  await (await token.approve(vaultAddress, amount)).wait();
  await (await vault.deposit(amount, signer.address)).wait();
}

async function borrow(vaultAddress: string, amount: bigint) {
  const vault = new ethers.Contract(vaultAddress, vaultABI, signer);
  await (await vault.borrow(amount, signer.address)).wait();
}

async function getBalance(vaultAddress: string, user: string) {
  const vault = new ethers.Contract(vaultAddress, vaultABI, provider);
  return await vault.balanceOf(user);
}

async function repay(vaultAddress: string, amount: bigint) {
  const vault = new ethers.Contract(vaultAddress, vaultABI, signer);
  const token = new ethers.Contract(assetAddress, erc20ABI, signer);

  await (await token.approve(vaultAddress, amount)).wait();
  await (await vault.repay(amount, signer.address)).wait();
}

async function withdraw(vaultAddress: string, amount: bigint) {
  const vault = new ethers.Contract(vaultAddress, vaultABI, signer);
  await (await vault.withdraw(amount, signer.address, signer.address)).wait();
}

const EVC_ADDRESS = "0xceAA7cdCD7dDBee8601127a9Abb17A974d613db4";
const evcABI = [
  "function batch(bytes[] calldata calls) external",
  "function setOperator(address operator, bool enabled) external",
];
const evc = new ethers.Contract(EVC_ADDRESS, evcABI, signer);

async function batchDepositAndBorrow(
  collateralVault: ethers.Contract,
  debtVault: ethers.Contract,
  depositAmount: bigint,
  borrowAmount: bigint
) {
  const calls = [
    collateralVault.interface.encodeFunctionData("deposit", [depositAmount, userAddress]),
    debtVault.interface.encodeFunctionData("borrow", [borrowAmount, userAddress]),
  ];
  await (await evc.batch(calls)).wait();
}

function getSubAccountAddress(userAddress: string, subAccountId: number): string {
  return `${userAddress}:${subAccountId}`;
}

// Deposit to sub-account 1
await vault.deposit(amount, `${userAddress}:1`);

await (await evc.setOperator(operatorAddress, true)).wait();
// Revoke:
await (await evc.setOperator(operatorAddress, false)).wait();

struct VaultConfig {
    address underlying;           // ERC-20 token
    address interestRateModel;    // IRM contract
    address oracleAdapter;        // Pyth, Chainlink, or custom
    uint256 collateralFactor;     // Max LTV in basis points (e.g. 7500 = 75%)
    uint256 liquidationThreshold; // Liquidation LTV in basis points
    uint256 liquidationDiscount;  // Liquidator bonus in basis points (e.g. 1000 = 10%)
    bool isBorrowable;            // false = collateral-only
    address[] hookTargets;        // optional hook contracts
}

IVaultFactory factory = IVaultFactory(0xcF5552580fD364cdBBFcB5Ae345f75674c59273A);
address vaultAddress = factory.deployVault(config);

Utilization = Total Borrowed / Total Deposited
Supply Rate = Borrow Rate × Utilization × (1 - Reserve Factor)

if Utilization < Optimal:
    Borrow Rate = Base + Utilization × Slope1
else:
    Borrow Rate = Base + Optimal × Slope1 + (Utilization - Optimal) × Slope2

Health Score = Total Collateral Value / Total Debt Value

Share Price = Total Assets / Total Shares

async function safeBatch(calls: string[]) {
  try {
    const tx = await evc.batch(calls);
    await tx.wait();
    return { success: true };
  } catch (error) {
    if (error.message.includes("insufficient balance")) {
      return { success: false, reason: "Insufficient balance" };
    }
    if (error.message.includes("health score")) {
      return { success: false, reason: "Health score violation" };
    }
    return { success: false, reason: error.message };
  }
}

// Simulate before executing
async function validateBatch(calls: string[]) {
  try {
    await evc.callStatic.batch(calls);
    return { valid: true };
  } catch (error) {
    return { valid: false, error: error.message };
  }
}