Auto Farming Bot: APY Normalization and Gas Minimization

Keeping funds in a single yield protocol and manually moving them when rates change means constantly losing to those with automation. APY on Aave, Compound, Curve, Convex, Yearn changes every block. Manual monitoring gives reaction times in hours — a bot reacts in minutes or even seconds. The problem is exacerbated by gas wars and MEV bots that front-run transactions. Without automatic yield farming, you can lose up to 30% of potential yield due to delayed protocol rotation. The main challenge is building a system where the cost of rotation (gas) does not eat the gains from switching protocols, and the switching logic is resilient to interface changes. Our DeFi automation approach, refined through 5 years of experience, covers this in detail.

How to Build an Auto-Farming Bot Without Gas Losses?

Common Pitfalls

Blind APY Chasing Without Gas Consideration

The most common mistake in auto-farming: the bot sees a 2% APY difference between Aave and Compound and rotates. On Ethereum mainnet, a withdrawal + approval + deposit transaction costs $20–50 in gas. On a $1000 position, that's 2–5% of the principal — the rotation becomes unprofitable. Each unnecessary rotation can cost $50 in gas. Manual monitoring averages a 6-hour delay; a bot reacts in 2 minutes — that's 180x faster. Rule: rotate only if (APY_new - APY_current) * position_size * time_horizon > gas_cost * safety_factor. time_horizon is the expected stay in the new protocol, safety_factor is 2–3× to account for uncertainty. On L2 (Arbitrum, Optimism), fees are $0.1–0.5, so the threshold is much lower. Proper gas optimization can save you up to $5,000 per month on a $100k position.

Unsynchronized Yield Data

APY in DeFi is not a fixed rate. It's a projection of the current pool state onto a year. Compound's supplyRatePerBlock is calculated from utilization rate right now. Aave adds reward tokens (AAVE staking) that need to be claimed and accounted separately. Convex shows a boosted APY that depends on your vault's veCRV balance. Without APY normalization, you're comparing apples to oranges. Our yield farming bot for Aave (Aave bot) and Compound (Compound bot) uses a unified methodology: base yield (from protocol) + reward yield (from emissions, normalized to USD) + compound effect (reinvestment), all smoothed with a 7-day moving average. This avoids false triggers from short-term spikes.

Why APY Normalization Matters?

Without normalization, you compare apples to oranges. Our bot applies an adapter for each protocol that normalizes yield to a common standard. For example, for Aave V3 we account for liquidityRate + aToken reinvestment, for Compound V3 — supplyRate + compensation tokens. All data is smoothed with a 7-day moving average to filter out short-term spikes. This provides a stable signal for decision making and enables yield arbitrage between pools.

How to Calculate the Rotation Threshold Considering Gas?

The threshold is computed dynamically for each protocol pair. We use the formula:

• gas_cost — gas estimate via eth_estimateGas for Multicall3 (single tx for approve+deposit).
• profit = (APY_new - APY_current) * position * expected_stay_days / 365.
• Rotation occurs if profit > gas_cost * 2 (double buffer).

For multi-chain farming, bridge cost is also considered — it can be significant, so we typically only allow bridge rotations with manual confirmation. Potential additional yield with proper gas optimization is up to $5,000 per month on a $100k position.

How to Build a Rotation Strategy: Step-by-Step

1. Normalize APY — bring each protocol's yield to a common standard using a 7-day moving average.
2. Calculate gas threshold — for each protocol pair, dynamically compute the APY difference at which rotation is profitable.
3. Apply risk filters — exclude unaudited protocols, low-liquidity pools, forbid bridge rotations without manual confirmation.
4. Test on a fork — run all scenarios on a real network state using Foundry vm.createFork.
5. Deploy and monitor — launch the keeper bot with Telegram notifications and alerts on failures.

Auto-Farming Bot Architecture

System Layers

• Data layer: Aggregates data from protocols. Each protocol has its own adapter. Aave V3 via IPool.getReserveData(), Compound V3 via CometSupply events + getSupplyRate(), Curve via get_virtual_price() and Convex rewardRate. Data is written to Redis with a 60-second TTL to avoid hitting the RPC on every calculation.
• Strategy engine: Decision-making logic. Evaluates the current position, all rotation candidates, calculates net APY considering gas, and makes the decision. Also includes risk filters: avoid unaudited protocols, no more than X% in one protocol, exclude pools with TVL below threshold (liquidity risk on withdrawal).
• Execution layer: Builds and sends transactions. Uses viem for typed contracts via ABI and correct gas estimation. For batching: Multicall3 combines approve and deposit in one transaction, reducing gas by 30–40%.
• Monitoring: Telegram notifications for each rotation (amount invested, destination, expected APY), alerts on transaction errors, dashboard with position history via The Graph or custom indexer.

On-chain vs Off-chain Logic

Two approaches:

• Off-chain keeper (simpler, cheaper): bot runs on a server, holds a private key (or connects to Gnosis Safe via Safe Transaction Service API), sends transactions directly. Downside: dependence on server uptime and trust in the server.
• On-chain vault with keeper (more complex, safer): a smart contract vault holds funds; the keeper (bot) only calls rebalance(). The strategy is encoded in the contract — users can verify the logic. The keeper's private key can only call rebalance(), not withdraw funds. This is the standard for Yearn-style vaults, described in EIP-4626.

For a personal bot with a small amount, an off-chain keeper suffices. For a protocol with third-party funds, only an on-chain vault with an audit.

Multi-Network Support

Multi-chain farming requires bridge rotations, which we usually don't automate due to bridge exploit risks. For multichain bots, we only use manual confirmation for bridge operations.

Tech Stack

TypeScript + viem for on-chain interactions. Node.js for the keeper process. Redis for data caching. PostgreSQL for rotation history and analytics. Docker for deployment. PM2 or systemd for process monitoring.

Hardhat/Foundry for on-chain vault contracts, if we choose that path. Tests on forked mainnet via Foundry vm.createFork — we run rotation scenarios on the real network state.

What's Included in the Work

• Analysis of selected protocols and networks, APY normalization.
• Development of adapters for each protocol (including data collection and transaction submission).
• Implementation of the strategy engine with gas awareness and risk filters.
• Monitoring setup (Telegram, dashboard).
• Testing on forked mainnet (Foundry).
• Documentation for setup and operation.
• 3-month code warranty.

Time Estimates

• Off-chain keeper bot for 2–3 protocols on one network: 3–5 days.
• With APY normalization, gas consideration, and Telegram monitoring: closer to 1 week.
• On-chain Yearn-style vault with separate strategies: 2–4 weeks including tests.

Cost is calculated after specifying protocols and networks. With 5 years of experience and 15+ completed projects, we ensure reliable DeFi automation. Get a consultation — we'll assess your project for free.

protocols: - name: aave-v3-eth adapter: aave-v3 pool: 0x... gas_estimate: 200000 - name: compound-v3-eth adapter: compound-v3 comet: 0x... strategy: min_profit_multiple: 2 max_rotations_per_day: 10 excluded_protocols: - convex (outdated audit)