Keeper Bot (Liquidator Bot)

A keeper bot's primary role is to monitor collateralized debt positions (CDPs) on lending protocols like Aave or Compound. When a position's health factor or collateralization ratio falls below a safe threshold, the bot automatically executes a liquidation. This involves repaying the undercollateralized debt in exchange for the collateral at a discount, securing the protocol's solvency and earning a liquidation bonus for the keeper.

Keeper bots identify and exploit price discrepancies across decentralized exchanges (DEXs) and oracles. For example, if ETH trades for $1,900 on Uniswap but the Chainlink oracle reports $1,905, a bot can buy low on Uniswap and sell high in a protocol using the oracle price. This activity enforces price convergence and market efficiency, with profits derived from the arbitrage spread.

In automated market maker pools, keeper bots perform critical maintenance functions:

• Rebalancing: Adding/removing liquidity to maintain target weightings in index pools or Balancer V2.
• Limit Order Execution: Monitoring prices to fill user-placed limit orders on DEXs like Uniswap V3, acting as an off-chain order book executor.
• Fee Collection: Automatically harvesting and compounding accrued fees from liquidity positions.

Certain protocols rely on keepers to push external data on-chain. For instance, Chainlink Keepers or Gelato Network bots are triggered by time-based or event-based conditions to:

• Update TWAP (Time-Weighted Average Price) oracles.
• Execute periodic yield harvesting and reinvestment in vault strategies.
• Settle expiring options or futures contracts based on final price data.

Keeper ecosystems are driven by cryptoeconomic incentives. Key mechanisms include:

• Gas Price Optimization: Bots compete to submit transactions with optimal gas fees to be included in the next block.
• Priority Gas Auctions (PGAs): During high-demand events like liquidations, bots may engage in bidding wars, driving up transaction fees.
• Profit Maximization: A keeper's revenue is the execution reward (e.g., liquidation bonus) minus the transaction cost (gas).

A typical keeper bot runs off-chain and consists of:

• Event Listeners: Monitoring the mempool and on-chain events via RPC nodes.
• Strategy Logic: Code that calculates profitability and constructs transactions.
• Transaction Management: Handling nonce management and gas estimation. Key risks include frontrunning by other bots, sandwich attacks, failed transactions due to slippage, and smart contract bugs in the target protocol.

The core function of a liquidator bot is to monitor collateralized debt positions (CDPs) for undercollateralization. When a position's health factor or collateral ratio falls below a protocol's threshold, the bot automatically repays the borrower's debt in exchange for the collateral at a discount, profiting from the spread. This process is essential for maintaining protocol solvency.

• Example: A user's ETH-backed loan on Aave becomes undercollateralized after a price drop. A keeper bot repays the user's USDC debt and seizes the ETH at a 5-10% discount.

Keeper bots identify and exploit price discrepancies of the same asset across different decentralized exchanges (DEXs) or between DEXs and centralized exchanges (CEXs). They execute a series of trades to buy low on one venue and sell high on another, capturing risk-free profit and helping to align market prices.

• Mechanism: The bot monitors price feeds, calculates potential profit after gas fees, and executes the trades atomically in a single transaction to avoid slippage and front-running.

On DEXs that lack native limit order functionality (like Uniswap v3), keeper bots fulfill this role. They monitor the market price and execute a user's trade only when it reaches their specified limit price. The bot submits the transaction on the user's behalf, often for a fee.

• Protocol Example: Gelato Network and Keep3r are networks that provide infrastructure for bots to execute these conditional orders reliably and in a decentralized manner.

In automated market maker (AMM) pools and yield farming strategies, keeper bots maintain optimal capital efficiency. They automatically adjust liquidity provider (LP) positions or harvest and compound yields to maximize returns.

• AMM Rebalancing: For Uniswap v3 LP positions, bots move liquidity ranges as the price moves to stay in the active tick.
• Yield Harvesting: Bots claim accrued reward tokens from staking or farming contracts and automatically reinvest them, compounding the user's yield.

Keeper bots ensure the accuracy and liveness of oracle price feeds, which are critical for loan valuations and derivative settlements. They can be incentivized to push new price data to on-chain oracles when certain conditions are met (e.g., a significant deviation from a reference feed).

In systems like UMA's Optimistic Oracle, bots also play a role in disputing proposed price updates during a challenge period, helping to secure the data feed.

Decentralized protocols often require regular, permissionless upkeep that keeper bots can automate. This includes triggering the conclusion of auctions, settling expired options or perpetual contracts, and executing governance-approved parameter changes (like adjusting interest rate models).

• Example: In MakerDAO's surplus auction (flap) or collateral auction (flip), keeper bots bid on excess system surplus or collateral to help stabilize the Dai stablecoin.

A keeper bot's primary role is to liquidate undercollateralized positions in lending protocols like Aave or Compound. It monitors user collateralization ratios and, when a position falls below the required liquidation threshold, the bot submits a transaction to repay the debt and seize the collateral, earning a liquidation bonus as its reward. This action protects the protocol from bad debt and maintains system solvency.

Keeper bots are key players in Maximal Extractable Value (MEV) strategies. They scan for price discrepancies across decentralized exchanges (DEXs) like Uniswap and centralized exchanges to execute profitable arbitrage trades. They also engage in sandwich attacks, front-running user transactions. These activities are often bundled into blocks by searchers and relayed to validators via services like Flashbots.

Beyond liquidations, keeper bots perform essential upkeep tasks for DeFi protocols. This includes triggering auctions in systems like MakerDAO's surplus and debt auctions, calling rebalance functions for algorithmic stablecoins, and executing limit orders on DEXs. These actions ensure protocols operate as designed, often requiring bots to be gas-optimized to outbid competitors for the same opportunity.

Keeper bots operate on a profit-driven economic model, where revenue from bonuses or arbitrage must exceed costs like gas fees and development. Key risks include:

• Gas price volatility making transactions unprofitable.
• Smart contract risk from bugs in the protocols they interact with.
• Competition from other, faster bots in a highly adversarial environment.

Running a keeper bot requires specialized infrastructure:

• RPC Nodes: Low-latency access to blockchain data (e.g., Alchemy, Infura).
• Event Listeners: To monitor on-chain events in real-time.
• Transaction Simulation: Tools like Tenderly to test trades before broadcasting.
• Private Mempools: Services like Flashbots Protect to avoid front-running.
• Gas Management: Strategies for optimal bid pricing.

A keeper bot (or liquidator bot) is an automated program that monitors on-chain positions for predefined conditions, such as a loan's collateral value falling below its required health factor. When triggered, it executes a liquidation transaction to close the undercollateralized position, protecting the lending protocol from bad debt. This automated enforcement is fundamental to the security of overcollateralized lending platforms like Aave and Compound.

Keepers are economically motivated by Maximal Extractable Value (MEV) opportunities. They compete to be the first to submit a profitable liquidation transaction, earning a liquidation bonus or fee. This creates a keeper economy where sophisticated bots with low-latency infrastructure and optimized gas bidding strategies capture value. The profit is typically a percentage of the collateral seized or a fixed reward paid by the protocol.

While essential, keeper activity introduces systemic considerations:

• Reliance on Profitability: If gas costs exceed liquidation rewards, keepers may not act, allowing bad debt to accumulate.
• Infrastructure Centralization: The need for speed and capital favors large, professional operations, potentially centralizing a critical security function.
• Frontrunning & Congestion: Keeper competition can lead to gas auctions and network congestion during market volatility.

Beyond liquidations, keeper bots perform arbitrage, closing price differences between decentralized exchanges (DEXs) like Uniswap and centralized markets. They also trigger limit orders, vault harvesting (claiming and compounding rewards in DeFi yield strategies), and rebalancing for automated portfolio managers. These actions collectively enhance market efficiency and ensure smart contracts operate as intended.

A typical keeper bot stack includes:

• Blockchain Node: For real-time event listening (e.g., new block headers, specific event logs).
• MemPool Monitor: To scan pending transactions for opportunities and avoid frontrunning.
• Execution Engine: Signs and broadcasts transactions, often with dynamic gas price strategies.
• Risk Management: Calculates profitability including gas costs, slippage, and reward size.

Protocols must carefully design their liquidation engine to ensure keeper reliability:

• Incentive Alignment: Setting liquidation rewards that are attractive under normal network conditions.
• Grace Periods: Some protocols implement a liquidation grace period to give position owners a chance to remediate.
• Partial vs. Full Liquidation: Defining the size of the position that can be liquidated in one transaction to manage market impact.

The core smart contract logic that defines liquidation conditions and auction mechanisms. It is the on-chain system that keeper bots monitor and interact with. Key components include:

• Health Factor/ Collateral Ratio: The metric determining when a position is undercollateralized.
• Liquidation Threshold: The specific value that triggers the liquidation process.
• Auction Types: Such as Dutch auctions (descending price) or fixed discount liquidations.

The profit a miner, validator, or searcher can extract by reordering, including, or censoring transactions within a block. Keeper bot activity is a primary source of on-chain MEV. This includes:

• Liquidation MEV: Profit from successfully liquidating an underwater position.
• Arbitrage MEV: Often bundled with liquidations when swapping seized collateral.
• Sandwich Attacks: Not directly related to liquidations, but another common MEV strategy performed by similar automated bots.

Uncollateralized loans that must be borrowed and repaid within a single blockchain transaction. Keeper bots use them as capital-efficient leverage to execute complex strategies. For example, a bot can:

1. Take a flash loan of a stablecoin.
2. Use it to repay a user's debt in a lending protocol.
3. Seize the user's collateral at a discount.
4. Sell the collateral on a DEX.
5. Repay the flash loan, keeping the profit—all atomically.

Critical techniques for ensuring a keeper's transaction is included in the next block ahead of competitors. This involves:

• Gas Price Bidding: Dynamically setting transaction fees (e.g., maxPriorityFeePerGas on Ethereum) to outbid other bots.
• Transaction Simulation: Testing the transaction in a local environment to ensure it will succeed and be profitable before broadcasting.
• Bundle Submission: Sending transactions directly to block builders via relays to bypass the public mempool.

The external data sources that provide the market prices used to calculate a position's health. Keeper bots are heavily dependent on their accuracy and latency. Key oracle models include:

• Decentralized Oracles (e.g., Chainlink): Aggregate data from multiple sources for robustness.
• TWAP Oracles: Use time-weighted average prices to resist short-term manipulation.
• Oracle Latency: The delay between a real-market price change and the on-chain update creates the opportunity window for liquidations.

The specialized software and network layer that professional keeper operations use. This ecosystem separates roles:

• Searchers: Run algorithms to find profitable opportunities (like liquidations) and create transaction bundles.
• Block Builders: Construct complete blocks, optimizing for MEV, and submit them to validators.
• Relays: Act as trusted intermediaries between searchers and builders, often providing transaction privacy to prevent front-running.