> For the complete documentation index, see [llms.txt](https://docs.convexfinance.com/convexfinanceintegration/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.convexfinance.com/convexfinanceintegration/booster.md).

# Booster

The [Booster.sol](https://github.com/convex-eth/platform/blob/main/contracts/contracts/Booster.sol) is the main deposit contract for LP tokens on the Convex platform (Ethereum mainnet). Deposit Curve LP tokens into the Booster and receive a 1:1 tokenized deposit that can be staked for boosted rewards.

Mainnet Booster: `0xF403C135812408BFbE8713b5A23a04b3D48AAE31`

```javascript
//main Convex contract(booster.sol) basic interface
interface IConvex{
    //deposit into convex, receive a tokenized deposit.  parameter to stake immediately
    function deposit(uint256 _pid, uint256 _amount, bool _stake) external returns(bool);
    //burn a tokenized deposit to receive curve lp tokens back
    function withdraw(uint256 _pid, uint256 _amount) external returns(bool);
}
```

### Pool Info

To gather pool information access the poolInfo array

```javascript
//number of pools
var poolLength = await booster.poolLength()
//get information for pool "n"
var poolInfo = await booster.poolInfo(n)
```

Pool information is returned in the following struct.

```javascript
struct PoolInfo {
        address lptoken;
        address token;
        address gauge;
        address crvRewards;
        address stash;
        bool shutdown;
}
```

**lptoken**: the underlying token (ex. the curve lp token)\
**token**: the convex deposit token (a 1:1 token representing an lp deposit). The supply of this token can be used to calculate the TVL of the pool\
**gauge**: the curve "gauge" or staking contract used by the pool\
**crvRewards**: the main reward contract for the pool\
**stash**: a helper contract used to hold extra rewards (like snx) on behalf of the pool until distribution is called\
**shutdown**: a shutdown flag of the pool

{% hint style="info" %}
For newer pools (ids 151+), the VirtualBalanceRewardPool reward token points to a wrapped version of the underlying reward token (`StashTokenWrapper`). See the Rewards page and the Staking Wrappers page for details.
{% endhint %}

### Deposits

There are two deposit commands, deposit() and depositAll(). Depositing into the booster will return a "**deposit token**" as a receipt. This token can be staked in the rewards contract to earn **CRV** and other rewards.

```javascript
//deposit into a pool "n" and receive the deposit token
await booster.deposit( n, amount, false )

//deposit into a pool "n" and immediately stake into the rewards contract
await booster.deposit( n, amount, true )

//deposit all lp tokens for pool "n" and stake into the rewards contract
await booster.depositAll( n, true )
```

### Withdrawals

There are two user-facing withdraw commands, withdraw() and withdrawAll(). By burning a convex deposit token you can receive the underlying LP token.

```javascript
//withdraw from pool "n"
await booster.withdraw( n, amount )

//withdraw all from pool "n"
await booster.withdrawAll( n )
```

Note: `withdrawTo(_pid, _amount, _to)` exists on the Booster but is **restricted to the pool's reward contract** (used internally when a reward pool unwraps during `withdrawAndUnwrap`). To withdraw directly to the underlying LP token, users call `withdrawAndUnwrap` on the pool's `crvRewards` contract instead (see the Rewards page).

### Earmarking (reward & fee harvesting)

Rewards are periodically claimed from the curve gauge and "earmarked": moved into the pool's reward contract. Two functions on the Booster perform this work:

```javascript
//claim + distribute rewards for a specific pool
await booster.earmarkRewards( n )

//claim + distribute veCRV platform fees (crvUSD) into the cvxCRV fee reward contract
await booster.earmarkFees()
```

Integrators building yield-aggregators or autocompounders typically call `earmarkRewards()` (optionally through the [Harvester](https://github.com/convex-eth/platform/blob/main/contracts/contracts/Harvester.sol) contract, which can batch many earmarks in one transaction) before querying/claiming rewards, so that the reward contracts reflect the most recently harvested gauge rewards.

### Reward distribution & fees

When a user claims CRV, a performance fee is taken. The fee split is governance-adjustable on the Booster in basis points (MaxFees = 2000). Current split:

| Component          | Value (bps) | Meaning                                           |
| ------------------ | ----------- | ------------------------------------------------- |
| `lockIncentive`    | 1000        | goes to cvxCRV stakers via `lockRewards`          |
| `stakerIncentive`  | 450         | goes to CVX stakers via `stakerRewards`           |
| `earmarkIncentive` | 50          | incentive for the caller that triggers earmarking |
| `platformFee`      | 200         | platform/treasury fee                             |

The Booster exposes the reward contracts directly:

```javascript
//cvx staking reward contract
await booster.stakerRewards()

//cvxCRV staking reward contract
await booster.lockRewards()

//cvxCRV veCRV-fees reward contract
await booster.lockFees()
```

### Gauge voting

Convex's voting proxy holds the protocol's veCRV, and the Booster exposes functions to cast votes:

```javascript
//vote for/against a Curve DAO ownership or parameter vote
await booster.vote( voteId, votingAddress, support )

//cast gauge weight votes (weights in Curve gauge-controller units: 0-10000 = 0-100%)
await booster.voteGaugeWeight( gauges, weights )
```

Note that both `vote()` and `voteGaugeWeight()` are **restricted to `msg.sender == voteDelegate`** on the Booster, and are generally executed through the vote-locked governance layer (`VoteDelegateExtension` / on-chain voting) rather than called directly on the Booster by integrators — see the On-Chain Voting page.

### Roles

Setters on the Booster are generally **self-administered** (each role can appoint its own successor) rather than owner-only:

* `setOwner` — owner-only; transfers the owner role.
* `setFeeManager` — callable by the current `feeManager`; the fee manager sets the fee split (`setFees`), triggers fee distribution configuration (`setFeeInfo()`), and sets the treasury.
* `setPoolManager` — callable by the current `poolManager`; pool manager adds/shuts down pools and manages factories.
* `setVoteDelegate` — callable by the current `voteDelegate`; vote delegate casts the protocol's Curve votes.
* `setFactories` — owner-only (reward/token factories are one-time-set; stash factory remains updatable to support new gauge types).
* `setArbitrator`, `setRewardContracts`, `shutdownSystem` — owner-gated.

The Booster is managed through `BoosterOwner` / `BoosterOwnerSecondary` / `BoosterRewardManager` module contracts. These modules each carry their own owner/permission model — at least some (e.g. `BoosterOwnerSecondary`, `BoosterRewardManager`) are owned by the Convex multisig, so do not assume every role change is routed through the on-chain voting system. Check each module's `owner()` and modifiers before integrating role-management expectations.

### Fee distribution

The Booster's `earmarkRewards()`/`earmarkFees()` surface shares the performance-fee logic used across the main platform: see the Rewards page for how hooks interact with the stash/earmark flow.