# IMaverickV2Reward

**Inherits:** [INft](/technical-reference/maverick-v2/v2-contracts/maverick-v2-supplemental-contracts/positionbase/inft.md), [IMulticall](/technical-reference/maverick-v2/v2-contracts/maverick-v2-common-contracts/base/imulticall.md), [IRewardAccounting](/technical-reference/maverick-v2/v2-contracts/maverick-v2-reward-contracts/rewardbase/irewardaccounting.md)

### Functions <a href="#functions" id="functions"></a>

#### MAX\_DURATION <a href="#max_duration" id="max_duration"></a>

```solidity
function MAX_DURATION() external view returns (uint256);
```

#### MIN\_DURATION <a href="#min_duration" id="min_duration"></a>

```solidity
function MIN_DURATION() external view returns (uint256);
```

#### UNBOOSTED\_MIN\_TIME\_GAP <a href="#unboosted_min_time_gap" id="unboosted_min_time_gap"></a>

This function retrieves the minimum time gap in seconds that must have elasped between calls to `pushUnboostedToVe()`.

```solidity
function UNBOOSTED_MIN_TIME_GAP() external view returns (uint256);
```

#### stakingToken <a href="#stakingtoken" id="stakingtoken"></a>

This function retrieves the address of the token used for staking in this reward contract.

```solidity
function stakingToken() external view returns (IERC20);
```

**Returns**

| Name     | Type     | Description                                |
| -------- | -------- | ------------------------------------------ |
| `<none>` | `IERC20` | The address of the staking token (IERC20). |

#### vault <a href="#vault" id="vault"></a>

This function retrieves the address of the MaverickV2RewardVault contract associated with this reward contract.

```solidity
function vault() external view returns (IMaverickV2RewardVault);
```

**Returns**

| Name     | Type                     | Description                                         |
| -------- | ------------------------ | --------------------------------------------------- |
| `<none>` | `IMaverickV2RewardVault` | The address of the IMaverickV2RewardVault contract. |

#### rewardInfo <a href="#rewardinfo" id="rewardinfo"></a>

This function retrieves information about all available reward tokens for this reward contract.

```solidity
function rewardInfo() external view returns (RewardInfo[] memory info);
```

**Returns**

| Name   | Type           | Description                                                                |
| ------ | -------------- | -------------------------------------------------------------------------- |
| `info` | `RewardInfo[]` | An array of RewardInfo structs containing details about each reward token. |

#### contractInfo <a href="#contractinfo" id="contractinfo"></a>

This function retrieves information about all available reward tokens and overall contract details for this reward contract.

```solidity
function contractInfo() external view returns (RewardInfo[] memory info, ContractInfo memory _contractInfo);
```

**Returns**

| Name            | Type           | Description                                                                |
| --------------- | -------------- | -------------------------------------------------------------------------- |
| `info`          | `RewardInfo[]` | An array of RewardInfo structs containing details about each reward token. |
| `_contractInfo` | `ContractInfo` | A ContractInfo struct containing overall contract details.                 |

#### earned <a href="#earned" id="earned"></a>

This function calculates the total amount of all earned rewards for a specific tokenId across all reward tokens.

```solidity
function earned(uint256 tokenId) external view returns (EarnedInfo[] memory earnedInfo);
```

**Parameters**

| Name      | Type      | Description                                                       |
| --------- | --------- | ----------------------------------------------------------------- |
| `tokenId` | `uint256` | The address of the tokenId for which to calculate earned rewards. |

**Returns**

| Name         | Type           | Description                                                                                      |
| ------------ | -------------- | ------------------------------------------------------------------------------------------------ |
| `earnedInfo` | `EarnedInfo[]` | An array of EarnedInfo structs containing details about earned rewards for each supported token. |

#### earned <a href="#earned-1" id="earned-1"></a>

This function calculates the total amount of earned rewards for a specific tokenId for a particular reward token.

```solidity
function earned(uint256 tokenId, IERC20 rewardTokenAddress) external view returns (uint256);
```

**Parameters**

| Name                 | Type      | Description                                                       |
| -------------------- | --------- | ----------------------------------------------------------------- |
| `tokenId`            | `uint256` | The address of the tokenId for which to calculate earned rewards. |
| `rewardTokenAddress` | `IERC20`  | The address of the specific reward token.                         |

**Returns**

| Name     | Type      | Description                                                        |
| -------- | --------- | ------------------------------------------------------------------ |
| `<none>` | `uint256` | amount The total amount of earned rewards for the specified token. |

#### tokenIndex <a href="#tokenindex" id="tokenindex"></a>

This function retrieves the internal index associated with a specific reward token address.

```solidity
function tokenIndex(IERC20 rewardToken) external view returns (uint8 rewardTokenIndex);
```

**Parameters**

| Name          | Type     | Description                                           |
| ------------- | -------- | ----------------------------------------------------- |
| `rewardToken` | `IERC20` | The address of the reward token to get the index for. |

**Returns**

| Name               | Type    | Description                                                         |
| ------------------ | ------- | ------------------------------------------------------------------- |
| `rewardTokenIndex` | `uint8` | The internal index of the token within the reward contract (uint8). |

#### rewardTokenCount <a href="#rewardtokencount" id="rewardtokencount"></a>

This function retrieves the total number of supported reward tokens in this reward contract.

```solidity
function rewardTokenCount() external view returns (uint256);
```

**Returns**

| Name     | Type      | Description                                        |
| -------- | --------- | -------------------------------------------------- |
| `<none>` | `uint256` | count The total number of reward tokens (uint256). |

#### transferAndNotifyRewardAmount <a href="#transferandnotifyrewardamount" id="transferandnotifyrewardamount"></a>

This function transfers a specified amount of reward tokens from the caller to distribute them over a defined duration. The caller will need to approve this rewards contract to make the transfer on the caller's behalf. See `notifyRewardAmount` for details of how the duration is set by the rewards contract.

```solidity
function transferAndNotifyRewardAmount(IERC20 rewardToken, uint256 duration, uint256 amount)
    external
    returns (uint256 _duration);
```

**Parameters**

| Name          | Type      | Description                                                     |
| ------------- | --------- | --------------------------------------------------------------- |
| `rewardToken` | `IERC20`  | The address of the reward token to transfer.                    |
| `duration`    | `uint256` | The duration (in seconds) over which to distribute the rewards. |
| `amount`      | `uint256` | The amount of reward tokens to transfer.                        |

**Returns**

| Name        | Type      | Description                                                           |
| ----------- | --------- | --------------------------------------------------------------------- |
| `_duration` | `uint256` | The duration in seconds that the incentives will be distributed over. |

#### notifyRewardAmount <a href="#notifyrewardamount" id="notifyrewardamount"></a>

This function notifies the vault to distribute a previously transferred amount of reward tokens over a defined duration. (Assumes tokens are already in the contract).

The duration of the distribution may not be the same as the input duration. If this notify amount is less than the amount already pending disbursement, then this new amount will be distributed as the same rate as the existing rate and that will dictate the duration. Alternatively, if the amount is more than the pending disbursement, then the input duration will be honored and all pending disbursement tokens will also be distributed at this newly set rate.

```solidity
function notifyRewardAmount(IERC20 rewardToken, uint256 duration) external returns (uint256 _duration);
```

**Parameters**

| Name          | Type      | Description                                                     |
| ------------- | --------- | --------------------------------------------------------------- |
| `rewardToken` | `IERC20`  | The address of the reward token to distribute.                  |
| `duration`    | `uint256` | The duration (in seconds) over which to distribute the rewards. |

**Returns**

| Name        | Type      | Description                                                           |
| ----------- | --------- | --------------------------------------------------------------------- |
| `_duration` | `uint256` | The duration in seconds that the incentives will be distributed over. |

#### transferAndStake <a href="#transferandstake" id="transferandstake"></a>

This function transfers a specified amount of staking tokens from the caller to the staking `vault()` and stakes them on the recipient's behalf. The user has to approve this reward contract to transfer the staking token on their behalf for this function not to revert.

```solidity
function transferAndStake(uint256 tokenId, uint256 _amount) external returns (uint256 amount, uint256 stakedTokenId);
```

**Parameters**

| Name      | Type      | Description                                         |
| --------- | --------- | --------------------------------------------------- |
| `tokenId` | `uint256` | Nft tokenId to stake for the staked tokens.         |
| `_amount` | `uint256` | The amount of staking tokens to transfer and stake. |

**Returns**

| Name            | Type      | Description                                                                                                               |
| --------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
| `amount`        | `uint256` | The amount of staking tokens staked. May differ from input if there were unstaked tokens in the vault prior to this call. |
| `stakedTokenId` | `uint256` | TokenId where liquidity was staked to. This may differ from the input tokenIf if the input `tokenId=0`.                   |

#### stake <a href="#stake" id="stake"></a>

This function stakes the staking tokens to the specified tokenId. If `tokenId=0` is passed in, then this function will look up the caller's tokenIds and stake to the zero-index tokenId. If the user does not yet have a staking NFT tokenId, this function will mint one for the sender and stake to that newly-minted tokenId.

The amount staked is derived by looking at the new balance on the `vault()`. So, for staking to yield a non-zero balance, the user will need to have transfered the `stakingToken()` to the `vault()` prior to calling `stake`. Note, tokens sent to the reward contract instead of the vault will not be stakable and instead will be eligible to be disbursed as rewards to stakers. This is an advanced usage function. If in doubt about the mechanics of staking, use `transferAndStake()` instead.

```solidity
function stake(uint256 tokenId) external returns (uint256 amount, uint256 stakedTokenId);
```

**Parameters**

| Name      | Type      | Description                                       |
| --------- | --------- | ------------------------------------------------- |
| `tokenId` | `uint256` | The address of the tokenId whose tokens to stake. |

**Returns**

| Name            | Type      | Description                                                                                             |
| --------------- | --------- | ------------------------------------------------------------------------------------------------------- |
| `amount`        | `uint256` | The amount of staking tokens staked (uint256).                                                          |
| `stakedTokenId` | `uint256` | TokenId where liquidity was staked to. This may differ from the input tokenIf if the input `tokenId=0`. |

#### unstakeToOwner <a href="#unstaketoowner" id="unstaketoowner"></a>

This function initiates unstaking of a specified amount of staking tokens for the caller and sends them to a recipient.

```solidity
function unstakeToOwner(uint256 tokenId, uint256 amount) external;
```

**Parameters**

| Name      | Type      | Description                                         |
| --------- | --------- | --------------------------------------------------- |
| `tokenId` | `uint256` | The address of the tokenId whose tokens to unstake. |
| `amount`  | `uint256` | The amount of staking tokens to unstake (uint256).  |

#### unstake <a href="#unstake" id="unstake"></a>

This function initiates unstaking of a specified amount of staking tokens on behalf of a specific tokenId and sends them to a recipient.

To unstakeFrom, the caller must have an approval allowance of at least `amount`. Approvals follow the ERC-20 approval/allowance interface.

```solidity
function unstake(uint256 tokenId, address recipient, uint256 amount) external;
```

**Parameters**

| Name        | Type      | Description                                            |
| ----------- | --------- | ------------------------------------------------------ |
| `tokenId`   | `uint256` | The address of the tokenId whose tokens to unstake.    |
| `recipient` | `address` | The address to which the unstaked tokens will be sent. |
| `amount`    | `uint256` | The amount of staking tokens to unstake (uint256).     |

#### getRewardToOwner <a href="#getrewardtoowner" id="getrewardtoowner"></a>

This function retrieves the claimable reward for a specific reward token and stake duration for the caller.

```solidity
function getRewardToOwner(uint256 tokenId, uint8 rewardTokenIndex, uint256 stakeDuration)
    external
    returns (RewardOutput memory rewardOutput);
```

**Parameters**

| Name               | Type      | Description                                                  |
| ------------------ | --------- | ------------------------------------------------------------ |
| `tokenId`          | `uint256` | The address of the tokenId whose reward to claim.            |
| `rewardTokenIndex` | `uint8`   | The internal index of the reward token.                      |
| `stakeDuration`    | `uint256` | The duration (in seconds) for which the rewards were staked. |

**Returns**

| Name           | Type           | Description                                                          |
| -------------- | -------------- | -------------------------------------------------------------------- |
| `rewardOutput` | `RewardOutput` | A RewardOutput struct containing details about the claimable reward. |

#### getRewardToOwnerForExistingVeLockup <a href="#getrewardtoownerforexistingvelockup" id="getrewardtoownerforexistingvelockup"></a>

This function retrieves the claimable reward for a specific reward token, stake duration, and lockup ID for the caller.

```solidity
function getRewardToOwnerForExistingVeLockup(
    uint256 tokenId,
    uint8 rewardTokenIndex,
    uint256 stakeDuration,
    uint256 lockupId
) external returns (RewardOutput memory);
```

**Parameters**

| Name               | Type      | Description                                                  |
| ------------------ | --------- | ------------------------------------------------------------ |
| `tokenId`          | `uint256` | The address of the tokenId whose reward to claim.            |
| `rewardTokenIndex` | `uint8`   | The internal index of the reward token.                      |
| `stakeDuration`    | `uint256` | The duration (in seconds) for which the rewards were staked. |
| `lockupId`         | `uint256` | The unique identifier for the specific lockup (optional).    |

**Returns**

| Name     | Type           | Description                                                                       |
| -------- | -------------- | --------------------------------------------------------------------------------- |
| `<none>` | `RewardOutput` | rewardOutput A RewardOutput struct containing details about the claimable reward. |

#### getRewardForExistingVeLockup <a href="#getrewardforexistingvelockup" id="getrewardforexistingvelockup"></a>

This function retrieves the claimable reward for a specific reward token, stake duration, lockup ID, and sends it to a recipient for a specified tokenId.

If the reward is staked in the corresponding veToken, the `lockupId` lockup will be extended on the veToken contract. Any existing lock on that lockupId will also be extended. To use this function, this reward contract will have to be approved as an extender on the veToken contract.

```solidity
function getRewardForExistingVeLockup(
    uint256 tokenId,
    address recipient,
    uint8 rewardTokenIndex,
    uint256 stakeDuration,
    uint256 lockupId
) external returns (RewardOutput memory);
```

**Parameters**

| Name               | Type      | Description                                                                        |
| ------------------ | --------- | ---------------------------------------------------------------------------------- |
| `tokenId`          | `uint256` | The address of the tokenId whose reward to claim.                                  |
| `recipient`        | `address` | The address to which the claimed reward will be sent.                              |
| `rewardTokenIndex` | `uint8`   | The internal index of the reward token.                                            |
| `stakeDuration`    | `uint256` | The duration (in seconds) for which the rewards will be staked in the ve contract. |
| `lockupId`         | `uint256` | The unique identifier for the specific lockup to extend on the veToken contract.   |

**Returns**

| Name     | Type           | Description                                                                       |
| -------- | -------------- | --------------------------------------------------------------------------------- |
| `<none>` | `RewardOutput` | rewardOutput A RewardOutput struct containing details about the claimable reward. |

#### getReward <a href="#getreward" id="getreward"></a>

This function retrieves the claimable reward for a specific reward token and stake duration for a specified tokenId and sends it to a recipient. If the reward is staked in the corresponding veToken, a new lockup in the ve token will be created.

```solidity
function getReward(uint256 tokenId, address recipient, uint8 rewardTokenIndex, uint256 stakeDuration)
    external
    returns (RewardOutput memory);
```

**Parameters**

| Name               | Type      | Description                                                                        |
| ------------------ | --------- | ---------------------------------------------------------------------------------- |
| `tokenId`          | `uint256` | The address of the tokenId whose reward to claim.                                  |
| `recipient`        | `address` | The address to which the claimed reward will be sent.                              |
| `rewardTokenIndex` | `uint8`   | The internal index of the reward token.                                            |
| `stakeDuration`    | `uint256` | The duration (in seconds) for which the rewards will be staked in the ve contract. |

**Returns**

| Name     | Type           | Description                                                                       |
| -------- | -------------- | --------------------------------------------------------------------------------- |
| `<none>` | `RewardOutput` | rewardOutput A RewardOutput struct containing details about the claimable reward. |

#### tokenList <a href="#tokenlist" id="tokenlist"></a>

This function retrieves a list of all supported tokens in the reward contract.

```solidity
function tokenList(bool includeStakingToken) external view returns (IERC20[] memory tokens);
```

**Parameters**

| Name                  | Type   | Description                                                         |
| --------------------- | ------ | ------------------------------------------------------------------- |
| `includeStakingToken` | `bool` | A flag indicating whether to include the staking token in the list. |

**Returns**

| Name     | Type       | Description                         |
| -------- | ---------- | ----------------------------------- |
| `tokens` | `IERC20[]` | An array of IERC20 token addresses. |

#### veTokenByIndex <a href="#vetokenbyindex" id="vetokenbyindex"></a>

This function retrieves the veToken contract associated with a specific index within the reward contract.

```solidity
function veTokenByIndex(uint8 index) external view returns (IMaverickV2VotingEscrow output);
```

**Parameters**

| Name    | Type    | Description                           |
| ------- | ------- | ------------------------------------- |
| `index` | `uint8` | The index of the veToken to retrieve. |

**Returns**

| Name     | Type                      | Description                                                     |
| -------- | ------------------------- | --------------------------------------------------------------- |
| `output` | `IMaverickV2VotingEscrow` | The IMaverickV2VotingEscrow contract associated with the index. |

#### rewardTokenByIndex <a href="#rewardtokenbyindex" id="rewardtokenbyindex"></a>

This function retrieves the reward token contract associated with a specific index within the reward contract.

```solidity
function rewardTokenByIndex(uint8 index) external view returns (IERC20 output);
```

**Parameters**

| Name    | Type    | Description                                |
| ------- | ------- | ------------------------------------------ |
| `index` | `uint8` | The index of the reward token to retrieve. |

**Returns**

| Name     | Type     | Description                                    |
| -------- | -------- | ---------------------------------------------- |
| `output` | `IERC20` | The IERC20 contract associated with the index. |

#### boostedAmount <a href="#boostedamount" id="boostedamount"></a>

This function calculates the boosted amount an tokenId would receive based on their veToken balance and stake duration.

```solidity
function boostedAmount(uint256 tokenId, IMaverickV2VotingEscrow veToken, uint256 rawAmount, uint256 stakeDuration)
    external
    view
    returns (uint256 earnedAmount, bool asVe);
```

**Parameters**

| Name            | Type                      | Description                                                                      |
| --------------- | ------------------------- | -------------------------------------------------------------------------------- |
| `tokenId`       | `uint256`                 | The address of the tokenId for which to calculate the boosted amount.            |
| `veToken`       | `IMaverickV2VotingEscrow` | The IMaverickV2VotingEscrow contract representing the veToken used for boosting. |
| `rawAmount`     | `uint256`                 | The raw (unboosted) amount.                                                      |
| `stakeDuration` | `uint256`                 | The duration (in seconds) for which the rewards would be staked.                 |

**Returns**

| Name           | Type      | Description                                                                                                                          |
| -------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| `earnedAmount` | `uint256` | The boosted amount the tokenId would receive (uint256).                                                                              |
| `asVe`         | `bool`    | A boolean indicating whether the boosted amount is staked in the veToken (true) or is disbursed without ve staking required (false). |

#### pushUnboostedToVe <a href="#pushunboostedtove" id="pushunboostedtove"></a>

This function is used to push unboosted rewards to the veToken contract. This unboosted reward amount is then distributed to the veToken holders. This function will revert if less than `UNBOOSTED_MIN_TIME_GAP()` seconds have passed since the last call.

```solidity
function pushUnboostedToVe(uint8 rewardTokenIndex)
    external
    returns (uint128 amount, uint48 timepoint, uint256 batchIndex);
```

**Parameters**

| Name               | Type    | Description                             |
| ------------------ | ------- | --------------------------------------- |
| `rewardTokenIndex` | `uint8` | The internal index of the reward token. |

**Returns**

| Name         | Type      | Description                                                |
| ------------ | --------- | ---------------------------------------------------------- |
| `amount`     | `uint128` | The amount of unboosted rewards pushed (uint128).          |
| `timepoint`  | `uint48`  | The timestamp associated with the pushed rewards (uint48). |
| `batchIndex` | `uint256` | The batch index for the pushed rewards (uint256).          |

#### mint <a href="#mint" id="mint"></a>

Mints an NFT stake to a user. This NFT will not possesses any assets until a user `stake`s asset to the NFT tokenId as part of a separate call.

```solidity
function mint(address recipient) external returns (uint256 tokenId);
```

**Parameters**

| Name        | Type      | Description                          |
| ----------- | --------- | ------------------------------------ |
| `recipient` | `address` | The address that owns the output NFT |

#### mintToSender <a href="#minttosender" id="minttosender"></a>

Mints an NFT stake to caller. This NFT will not possesses any assets until a user `stake`s asset to the NFT tokenId as part of a separate call.

```solidity
function mintToSender() external returns (uint256 tokenId);
```

### Events <a href="#events" id="events"></a>

#### NotifyRewardAmount <a href="#notifyrewardamount-1" id="notifyrewardamount-1"></a>

```solidity
event NotifyRewardAmount(
    address sender, IERC20 rewardTokenAddress, uint256 amount, uint256 duration, uint256 rewardRate
);
```

#### GetReward <a href="#getreward-1" id="getreward-1"></a>

```solidity
event GetReward(
    address sender,
    uint256 tokenId,
    address recipient,
    uint8 rewardTokenIndex,
    uint256 stakeDuration,
    IERC20 rewardTokenAddress,
    RewardOutput rewardOutput,
    uint256 lockupId
);
```

#### UnStake <a href="#unstake-1" id="unstake-1"></a>

```solidity
event UnStake(
    address sender, uint256 tokenId, uint256 amount, address recipient, uint256 userBalance, uint256 totalSupply
);
```

#### Stake <a href="#stake-1" id="stake-1"></a>

```solidity
event Stake(
    address sender, address supplier, uint256 amount, uint256 tokenId, uint256 userBalance, uint256 totalSupply
);
```

#### AddRewardToken <a href="#addrewardtoken" id="addrewardtoken"></a>

```solidity
event AddRewardToken(IERC20 rewardTokenAddress, uint8 rewardTokenIndex);
```

#### RemoveRewardToken <a href="#removerewardtoken" id="removerewardtoken"></a>

```solidity
event RemoveRewardToken(IERC20 rewardTokenAddress, uint8 rewardTokenIndex);
```

#### ApproveRewardGetter <a href="#approverewardgetter" id="approverewardgetter"></a>

```solidity
event ApproveRewardGetter(uint256 tokenId, address getter);
```

### Errors <a href="#errors" id="errors"></a>

#### RewardDurationOutOfBounds <a href="#rewarddurationoutofbounds" id="rewarddurationoutofbounds"></a>

```solidity
error RewardDurationOutOfBounds(uint256 duration, uint256 minDuration, uint256 maxDuration);
```

#### RewardZeroAmount <a href="#rewardzeroamount" id="rewardzeroamount"></a>

```solidity
error RewardZeroAmount();
```

#### RewardNotValidRewardToken <a href="#rewardnotvalidrewardtoken" id="rewardnotvalidrewardtoken"></a>

```solidity
error RewardNotValidRewardToken(IERC20 rewardTokenAddress);
```

#### RewardNotValidIndex <a href="#rewardnotvalidindex" id="rewardnotvalidindex"></a>

```solidity
error RewardNotValidIndex(uint8 index);
```

#### RewardTokenCannotBeStakingToken <a href="#rewardtokencannotbestakingtoken" id="rewardtokencannotbestakingtoken"></a>

```solidity
error RewardTokenCannotBeStakingToken(IERC20 stakingToken);
```

#### RewardTransferNotSupported <a href="#rewardtransfernotsupported" id="rewardtransfernotsupported"></a>

```solidity
error RewardTransferNotSupported();
```

#### RewardNotApprovedGetter <a href="#rewardnotapprovedgetter" id="rewardnotapprovedgetter"></a>

```solidity
error RewardNotApprovedGetter(uint256 tokenId, address approved, address getter);
```

#### RewardUnboostedTimePeriodNotMet <a href="#rewardunboostedtimeperiodnotmet" id="rewardunboostedtimeperiodnotmet"></a>

```solidity
error RewardUnboostedTimePeriodNotMet(uint256 timestamp, uint256 minTimestamp);
```

### Structs <a href="#structs" id="structs"></a>

#### RewardInfo <a href="#rewardinfo-1" id="rewardinfo-1"></a>

```solidity
struct RewardInfo {
    uint256 finishAt;
    uint256 updatedAt;
    uint256 rewardRate;
    uint256 escrowedReward;
    uint256 rewardPerTokenStored;
    IERC20 rewardToken;
    IMaverickV2VotingEscrow veRewardToken;
    uint128 unboostedAmount;
    uint256 lastUnboostedPushTimestamp;
}
```

#### ContractInfo <a href="#contractinfo-1" id="contractinfo-1"></a>

```solidity
struct ContractInfo {
    string name;
    string symbol;
    uint256 totalSupply;
    IERC20 stakingToken;
}
```

#### EarnedInfo <a href="#earnedinfo" id="earnedinfo"></a>

```solidity
struct EarnedInfo {
    uint256 earned;
    IERC20 rewardToken;
}
```

#### RewardOutput <a href="#rewardoutput" id="rewardoutput"></a>

```solidity
struct RewardOutput {
    uint256 amount;
    bool asVe;
    IMaverickV2VotingEscrow veContract;
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.mav.xyz/technical-reference/maverick-v2/v2-contracts/maverick-v2-reward-contracts/interfaces/imaverickv2reward.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.