---
name: Silo Yield
description: Auto-compounding yield silos on Abstract Chain. Use this skill when building integrations with Silo Yield — depositing, withdrawing, harvesting, querying APYs, or building agent tools for yield farming on Abstract.
metadata:
  version: "1.0"
  chain: abstract
  chain_id: 2741
---

# Silo Yield on Abstract Chain

Auto-compounding yield silos on Abstract Chain (chain ID 2741). Deposit any token, earn optimized yield from Aborean DEX LP farming, Kona Finance lending, and concentrated liquidity positions — all auto-compounded.

## When to Use

- Building an AI agent that farms yield on Abstract Chain
- Integrating Silo Yield deposits/withdrawals into a dapp or bot
- Querying on-chain APY, TVL, or portfolio data from Silo silos
- Building a harvest bounty bot to earn caller fees
- Looking up Silo contract addresses, ABIs, or token addresses on Abstract

## Quick Start

```bash
# Install the MCP server for AI agent access
cd mcp && npm install && npm run build

# Run the MCP server
node mcp/dist/index.js
```

## Decision Table

| I want to... | Do this |
|---|---|
| Find the best yield | Call `list_silos` or `get_best_yield` via MCP, or read from factory contract |
| Deposit into a silo | Approve token → call `zapIn` on Zapper (or `zapInETH` for ETH) |
| Withdraw from a silo | Approve shares → call `zapOut` on Zapper, or `redeem` directly on silo |
| Check my positions | Call `balanceOf` on each silo, then `convertToAssets` for underlying value |
| Harvest rewards (earn fee) | Call `harvest(deadline, minCompounded)` on any silo — anyone can call this |
| Get token prices | Query Aborean Router `getAmountsOut` for on-chain quotes |
| Get APY for a silo | Depends on platform — see APY Calculation below |
| Deposit into a strategy | Approve underlying token → call `deposit` on strategy |
| List strategies | Call `list_strategies` via MCP, or `getAllStrategies()` on StrategyFactory |
| Check strategy positions | Call `balanceOf` on strategy, then `convertToAssets` for underlying value |

## Contract Addresses (Abstract Mainnet — Chain ID 2741)

| Contract | Address |
|---|---|
| Silo Factory | `0xfcE532BD1f46D321Bf0eBdEb1C2f2bcDd7754F93` |
| Zapper | `0x83f29aA57E3Df703368e369ECD811B3189f19afe` |
| Harvester | `0x9F78bd07A35Fa5903687FEF28c0e730a309D905E` |
| Aborean Router | `0xE8142D2f82036B6FC1e79E4aE85cF53FBFfDC998` |
| Pool Factory | `0xF6cDfFf7Ad51caaD860e7A35d6D4075d74039a6B` |
| Kona Lending Pool | `0x8f16B5713F412C5dE4951Aaf678Eb8409101f819` |

### Token Addresses

| Token | Address | Decimals |
|---|---|---|
| WETH | `0x3439153EB7AF838Ad19d56E1571FBD09333C2809` | 18 |
| USDC | `0x84A71ccD554Cc1b02749b35d22F684CC8ec987e1` | 6 |
| USDT | `0x0709F39376dEEe2A2dfC94A58EdEb2Eb9DF012bD` | 6 |
| ABX | `0x4C68E4102c0F120cce9F08625bd12079806b7C4D` | 18 |
| gBLUE | `0xC25714E79b694EeE7E8e8D21dae332A797d28Ac0` | 18 |
| PENGU | `0x9eBe3A824Ca958e4b3Da772D2065518F009CBa62` | 18 |
| Native ETH | `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE` | 18 |

## Silo Architecture

Silos are ERC-4626 vaults that auto-compound yield. There are 4 platform types:

| Platform | Type | How it works |
|---|---|---|
| `aborean` | V2 LP farming | Deposits into Aborean V2 LP pools, stakes in gauge, auto-compounds ABX rewards |
| `aborean-cl` | Concentrated liquidity | Manages CL positions on Aborean, auto-compounds gauge rewards |
| `kona` | Lending | Deposits into Kona Finance lending pools, earns interest |
| `veabx` | Vote escrow | Locks ABX for veABX voting power |

### Key Silo Functions

```solidity
// ERC-4626 standard
function deposit(uint256 assets, address receiver) returns (uint256 shares)
function withdraw(uint256 assets, address receiver, address owner) returns (uint256 shares)
function redeem(uint256 shares, address receiver, address owner) returns (uint256 assets)
function convertToAssets(uint256 shares) returns (uint256 assets)
function convertToShares(uint256 assets) returns (uint256 shares)
function totalAssets() returns (uint256)
function balanceOf(address account) returns (uint256)

// Silo-specific
function harvest(uint256 _deadline, uint256 _minCompounded) // anyone can call, earns callerFee
function pendingRewards() returns (uint256)
function lastHarvest() returns (uint256)
function callerFee() returns (uint256)      // bps paid to harvest caller
function performanceFee() returns (uint256) // bps taken as protocol fee
function paused() returns (bool)
function gauge() returns (address)          // Aborean gauge address
function pool() returns (address)           // underlying LP pool
function token0() returns (address)
function token1() returns (address)
function isStable() returns (bool)
```

### Zapper Functions

The Zapper handles single-token deposits/withdrawals, converting any supported token into the correct LP:

```solidity
// Deposit any ERC-20 token
function zapIn(address silo, address inputToken, uint256 amount, uint256 minShares, uint256 _deadline) returns (uint256 shares)

// Deposit native ETH
function zapInETH(address silo, uint256 minShares, uint256 _deadline) payable returns (uint256 shares)

// Withdraw to any ERC-20 token
function zapOut(address silo, uint256 shares, address outputToken, uint256 minOutput, uint256 _deadline) returns (uint256 outputAmount)

// Withdraw to native ETH
function zapOutETH(address silo, uint256 shares, uint256 minOutput, uint256 _deadline) returns (uint256 outputAmount)
```

### Factory Functions

```solidity
function getAllVaults() returns (address[])  // all silo addresses
function isVault(address) returns (bool)     // check if address is active silo
function vaultCount() returns (uint256)      // number of silos
```

## Strategies

Strategies are vault-of-vaults that automatically diversify deposits across multiple silos. Each strategy accepts a single underlying token and distributes it across weighted silo allocations.

### Active Strategies

| Strategy | Symbol | Underlying | Risk | Silos | Description |
|---|---|---|---|---|---|
| Abstract Yield WETH | ayWETH | WETH | Medium | 8 | Diversified WETH yield across lending & CL |
| Abstract Yield WETH Degen | ayWETH-D | WETH | High | 5 | Pure meme-pair CL exposure |
| Abstract Yield gtBTC | aygtBTC | gtBTC | Medium | 2 | Diversified BTC across CL pairs |

### Contract Addresses

| Contract | Address |
|---|---|
| Strategy Factory | `0x0f06f820e9775ff1ad94782b8737615cBFE41284` |
| ayWETH | `0x4C54eb5C547FD0C7AF7416dDd612eAd3221AD9b9` |
| ayWETH Degen | `0x6F09Ed47238B3220c7505c0FD16d75252652622d` |
| aygtBTC | `0xfC4f2B1be24E786E1f07750200F32454678f49ac` |

### Key Strategy Functions

```solidity
// ERC-4626 standard (same as silos)
function deposit(uint256 assets, address receiver) returns (uint256 shares)
function withdraw(uint256 assets, address receiver, address owner) returns (uint256 shares)
function redeem(uint256 shares, address receiver, address owner) returns (uint256 assets)
function convertToAssets(uint256 shares) returns (uint256 assets)
function balanceOf(address account) returns (uint256)
function totalAssets() returns (uint256)

// Strategy-specific
function getAllocations() returns (address[] silos, uint256[] weights)
function allocationCount() returns (uint256)
function paused() returns (bool)
```

### Strategy Factory Functions

```solidity
function getAllStrategies() returns (address[])
function isStrategy(address) returns (bool)
function strategyCount() returns (uint256)
function createStrategy(IERC20 underlying, string name, string symbol, address[] silos, uint256[] weights) returns (address)
```

### Strategy Deposit Flow
```
1. User has WETH and wants diversified yield
2. Approve WETH for strategy: WETH.approve(strategyAddress, amount)
3. Deposit: strategy.deposit(amount, receiver)
4. Strategy auto-splits across silos by weight
5. User receives strategy shares (ERC-4626)
```

### Strategy vs Silo — When to Use Which

| Use case | Use |
|---|---|
| Want to pick a specific pool/pair | Silo (direct deposit via Zapper) |
| Want automatic diversification | Strategy (deposit underlying token) |
| Want maximum control | Silo |
| Want set-and-forget | Strategy |
| Want to deposit any token | Silo (via Zapper, supports ETH/USDC/etc) |
| Want to deposit the underlying token only | Strategy (WETH for ayWETH, gtBTC for aygtBTC) |

## APY Calculation

### Aborean V2 Silos
1. Read `gauge` address from silo, `asset` (LP token) address
2. Read `rewardRate` and `totalSupply` from the gauge
3. Read `getReserves` and `totalSupply` from the LP pool
4. Calculate LP price: `(reserve0_usd + reserve1_usd) / pool_total_supply`
5. `APY = (rewardRate * seconds_per_year * abx_price_usd) / (gauge_total_supply * lp_price_usd) * 100`

### Aborean CL Silos
1. Read `clGauge` and `clPool` from silo
2. Read `rewardRate` from CL gauge, `liquidity` and `slot0` from CL pool
3. Calculate pool TVL from sqrt price and liquidity
4. `APY = (rewardRate * seconds_per_year * abx_price_usd) / pool_tvl_usd * 100`

### Kona Lending Silos
1. Call `getReserveData(underlying_token)` on Kona Pool (`0x8f16...`)
2. `APY = currentLiquidityRate / 1e27 * 100` (rate is in RAY units)

## Common Workflows

### Deposit Flow
```
1. User has USDC
2. Approve USDC for Zapper: USDC.approve(ZAPPER_ADDRESS, amount)
3. Zap in: Zapper.zapIn(siloAddress, USDC_ADDRESS, amount, 0, deadline)
4. User receives silo shares
```

### Harvest Bounty Flow (for agents)
```
1. Call pendingRewards() on each silo
2. If pending > threshold, call harvest(block.timestamp + 300, 0)
3. Earn callerFee % of harvested rewards in ABX
4. No approval needed — harvest is permissionless
```

### Portfolio Check Flow
```
1. Get all silos: Factory.getAllVaults()
2. For each silo: balanceOf(wallet) to get shares
3. convertToAssets(shares) to get underlying value
4. Multiply by token price for USD value
```

## RPC Configuration

```
Chain ID: 2741
RPC URL: https://api.mainnet.abs.xyz
Block Explorer: https://abscan.org
Currency: ETH
```

## HTTP API

Silo provides a public REST API at `siloyield.xyz/api/silos/` — no SDK or authentication needed:

| Endpoint | Description |
|---|---|
| `GET /api/silos` | List all silos with APY, TVL, risk. Params: `sort`, `platform`, `risk`, `token` |
| `GET /api/silos/best-yield` | Top APY silos. Params: `risk`, `token`, `top` |
| `GET /api/silos/harvest` | Silos with pending rewards and caller fee amounts |
| `GET /api/silos/prices` | Live token prices from on-chain DEX quotes |
| `GET /api/silos/portfolio?wallet=0x...` | Wallet positions across all silos |
| `GET /api/silos/{address}` | Detailed info on a specific silo |

## MCP Server

The Silo Yield MCP server (`mcp/` directory) provides 14 tools for AI agents:

`list_silos`, `get_silo_details`, `get_best_yield`, `get_portfolio`, `get_harvest_opportunities`, `estimate_earnings`, `get_deposit_tx`, `get_withdraw_tx`, `get_harvest_tx`, `get_token_prices`, `list_strategies`, `get_strategy_details`, `get_strategy_deposit_tx`, `get_strategy_withdraw_tx`

Install: `cd mcp && npm install && npm run build`
Run: `node mcp/dist/index.js` (communicates over stdio)

## Common Gotchas

- **Always set a deadline** on zap/harvest calls. Use `block.timestamp + 300` (5 minutes). Transactions without deadlines can be held and executed at unfavorable prices.
- **Approve before zapIn** — the Zapper needs token approval. Skip if using `zapInETH` (sends native ETH).
- **Check `paused()`** before depositing. Paused silos reject deposits and harvests.
- **`harvest()` is permissionless** — anyone can call it. The caller earns `callerFee` bps of the harvested rewards. This is by design.
- **Kona silos have no token1** — `token1()` returns `0x0000...`. Don't try to resolve its symbol.
- **CL silos use `clGauge`/`clPool`** not `gauge`/`pool` — check `vaultType()` first. Returns `"cl"` for concentrated liquidity silos.
- **veABX silos are lock-only** — deposits lock ABX as vote-escrowed tokens. Withdrawals have lock periods.
- **ABX is the reward token** for all Aborean silos. Kona silos earn interest in the deposited asset.
- **Token decimals vary** — USDC/USDT are 6 decimals, not 18. gtBTC is 8. Always check.
- **`convertToAssets(shares)`** gives the underlying asset value, not USD. Multiply by token price for USD.
- **Factory `getAllVaults()`** may include deregistered silos. Always filter with `isVault(address)`.
- **Strategies accept the underlying token directly** — no Zapper needed. Approve the strategy contract, then call `deposit(assets, receiver)`.
- **Strategy withdrawals use `redeem()`** — use `redeem(shares, receiver, owner)` to withdraw. The strategy converts shares to underlying across all silos.

## Verification Checklist

- [ ] Using correct chain ID (2741) and RPC URL
- [ ] Token approvals set before calling zapIn
- [ ] Deadline parameter is set (not 0)
- [ ] Checked `paused()` before deposit/harvest
- [ ] Using correct token decimals (6 for USDC/USDT, 18 for most others)
- [ ] Filtering `getAllVaults()` results with `isVault()` check
- [ ] Handling both single-asset (kona) and dual-asset (aborean) silos correctly

## Resources

- **Website**: https://siloyield.xyz
- **MCP Server**: `mcp/` directory in this repo
- **Abstract Chain Docs**: https://docs.abs.xyz
- **Abstract Block Explorer**: https://abscan.org