Pooled Markets Agent Reference

npm install ethers
# or
npm install viem

const POOL_ADDRESS = "0xceCcE0EB9DD2Ef7996e01e25DD70e461F918A14b";
const poolABI = [
  "function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external",
  "function withdraw(address asset, uint256 amount, address to) external returns (uint256)",
  "function borrow(address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf) external",
  "function repay(address asset, uint256 amount, uint256 interestRateMode, address onBehalfOf) external returns (uint256)",
  "function getUserAccountData(address user) external view returns (uint256 totalCollateralBase, uint256 totalDebtBase, uint256 availableBorrowsBase, uint256 currentLiquidationThreshold, uint256 ltv, uint256 healthFactor)",
  "function getReservesList() external view returns (address[] memory)",
];

const pool = new ethers.Contract(POOL_ADDRESS, poolABI, signer);
const token = new ethers.Contract(assetAddress, erc20ABI, signer);

// Approve then supply
await (await token.approve(POOL_ADDRESS, amount)).wait();
await (await pool.supply(assetAddress, amount, signer.address, 0)).wait();

// interestRateMode: 2 = variable (stable debt NOT supported on HypurrFi)
await (await pool.borrow(assetAddress, amount, 2, 0, signer.address)).wait();

await (await token.approve(POOL_ADDRESS, amount)).wait();
// Use ethers.MaxUint256 to repay full debt
await (await pool.repay(assetAddress, amount, 2, signer.address)).wait();

// Use ethers.MaxUint256 to withdraw all
const withdrawn = await pool.withdraw(assetAddress, amount, signer.address);

const data = await pool.getUserAccountData(userAddress);
const healthFactor = Number(data.healthFactor) / 1e18;
// healthFactor > 1.0 = safe, < 1.0 = liquidatable

// Enable E-Mode for a category (e.g., category 1 = USD-correlated)
await (await pool.setUserEMode(1)).wait();

// Disable E-Mode
await (await pool.setUserEMode(0)).wait();

const categoryId = await pool.getUserEMode(userAddress);
if (categoryId > 0) {
  const data = await pool.getEModeCategoryData(categoryId);
  console.log(`LTV: ${data.ltv / 100}%`);
  console.log(`Liquidation Threshold: ${data.liquidationThreshold / 100}%`);
  console.log(`Label: ${data.label}`);
}

function flashLoan(
    address receiverAddress,
    address[] calldata assets,
    uint256[] calldata amounts,
    uint256[] calldata modes,        // 0=no debt, 2=variable debt
    address onBehalfOf,
    bytes calldata params,
    uint16 referralCode              // use 0
) external

function flashLoanSimple(
    address receiverAddress,
    address asset,
    uint256 amount,
    bytes calldata params,
    uint16 referralCode              // use 0
) external

interface IFlashLoanReceiver {
    function executeOperation(
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata premiums,
        address initiator,
        bytes calldata params
    ) external returns (bool);
}

const totalPremium = await pool.FLASHLOAN_PREMIUM_TOTAL();      // basis points
const protocolPremium = await pool.FLASHLOAN_PREMIUM_TO_PROTOCOL();
// Fee waived for FLASH_BORROWER role (flashLoan only, not flashLoanSimple)

const tx = await pool.flashLoan(
  receiverContractAddress,
  [assetAddress],
  [ethers.parseUnits("1000", 6)],   // e.g., 1000 USDC
  [0],                               // mode 0 = no debt
  signer.address,
  "0x",                              // params
  0                                  // referralCode
);
await tx.wait();

Health Factor = (Σ collateral_value × liquidation_threshold) / Σ debt_value

function liquidationCall(
    address collateralAsset,
    address debtAsset,
    address user,
    uint256 debtToCover,    // use type(uint256).max for maximum (50% of debt)
    bool receiveAToken      // true = receive hyTokens, false = underlying
) external

async function findLiquidatablePositions(users: string[]) {
  const liquidatable = [];
  for (const user of users) {
    const data = await pool.getUserAccountData(user);
    const hf = Number(data.healthFactor) / 1e18;
    if (hf < 1.0) {
      liquidatable.push({
        user,
        healthFactor: hf,
        totalCollateral: data.totalCollateralBase,
        totalDebt: data.totalDebtBase,
      });
    }
  }
  return liquidatable;
}

const config = await pool.getConfiguration(collateralAsset);
const liquidationBonus = (Number(config) >> 32) & 0xFFFF;
const bonusPercent = (liquidationBonus - 10000) / 100; // e.g., 5%
// Profit = (collateral received × bonus%) - gas cost

const debtToken = new ethers.Contract(debtAsset, erc20ABI, signer);
await (await debtToken.approve(POOL_ADDRESS, debtToCover)).wait();

const tx = await pool.liquidationCall(
  collateralAsset,
  debtAsset,
  borrowerAddress,
  debtToCover,       // or ethers.MaxUint256 for max
  false              // receive underlying asset
);
await tx.wait();

// Supply collateral first, then borrow USDXL
const USDXL_ADDRESS = "0x..."; // query from pool.getReservesList()
await (await pool.borrow(USDXL_ADDRESS, amount, 2, 0, signer.address)).wait();

const usdxl = new ethers.Contract(USDXL_ADDRESS, erc20ABI, signer);
await (await usdxl.approve(POOL_ADDRESS, amount)).wait();
await (await pool.repay(USDXL_ADDRESS, amount, 2, signer.address)).wait();

async function safePoolCall(fn: () => Promise<any>) {
  try {
    const tx = await fn();
    await tx.wait();
    return { success: true };
  } catch (error) {
    if (error.message.includes("HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD")) {
      return { success: false, reason: "Would drop health factor below liquidation threshold" };
    }
    if (error.message.includes("NOT_ENOUGH_AVAILABLE_USER_BALANCE")) {
      return { success: false, reason: "Insufficient balance" };
    }
    if (error.message.includes("BORROWING_NOT_ENABLED")) {
      return { success: false, reason: "Borrowing not enabled for this asset" };
    }
    if (error.message.includes("STABLE_BORROWING_NOT_ENABLED")) {
      return { success: false, reason: "Stable borrowing not supported — use variable (mode 2)" };
    }
    return { success: false, reason: error.message };
  }
}