Infrared Protocol

The Infrared Protocol revolutionizes the way users engage with the Berachain ecosystem, particularly in how they stake consensus assets and receive the Proof-of-Liquidity inflation. It enables users to stake their assets effortlessly and receive IBGT, a liquid staked representation of BGT, significantly enhancing BGT's utility. Additionally, Infrared democratizes access to Validator staking through the IBERA contract suite, a liquid staking token tightly integrated with Proof-of-Liquidity (POL) and the Infrared ecosystem.

Learn More

• Architecture
• Deployed Addresses
• Audits

Contract Architecture

https://link.excalidraw.com/l/1Tuu8vTTCh1/1f3jMvwGuuS

Core Contracts

• full overview here

• IBERA.sol: Main liquid staking token contract. Handles minting/burning of iBERA, facilitates POL rewards and manages validators.

• InfraredVault.sol: Manages staking pools and reward distribution. Integrates with Berachain's POL system.

• InfraredDistributor.sol: Handles distribution of validator rewards and commission management.

• BribeCollector.sol: Collects and auctions bribes from Berachain reward vaults.

Staking Contracts

• full overview here

• IBERADepositor.sol: Handles deposits to CL through Berachain beacon deposit contract.

• IBERAWithdrawor.sol: Manages withdrawals from CL through Berachain precompiles.

• IBERAClaimor.sol: Processes user claims for withdrawn funds.

• IBERAFeeReceivor.sol: Receives and processes validator rewards from EL.

Voting Contracts

• full overview here

• VotingEscrow.sol: Implementation of vote-escrowed NFTs (veNFTs) for protocol governance.

• Voter.sol: Manages voting logic for POL cutting board allocation.

• MultiRewards.sol: Base contract for reward distribution across multiple tokens.

Getting Started

Prerequisites

# Install Foundry
curl -L https://foundry.paradigm.xyz | bash
foundryup

Quick Start

# Clone the repository
git clone https://github.com/infrared-dao/infrared-contracts.git
cd infrared-protocol

# Install dependencies
forge install

# Build contracts
forge build

# Run tests
forge test

Integration Guide

Developers who want to integrate with InfraredVault and IBGTVault can do so by following these steps:

Installation

Add the infrared-contracts to your Foundry project:

forge install infrared-dao/infrared-contracts

Update your foundry.toml with the following remapping:

@infrared/=lib/infrared-contracts/contracts

Example Usage

import {IInfrared} from '@infrared/interfaces/IInfrared.sol';
import {IInfraredVault} from '@infrared/interfaces/IInfraredVault.sol';
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

// Query InfraredVault
IInfraredVault infraredVault = IInfrared(infrared).vaultRegistry(asset);

// Stake into InfraredVault
IERC20(asset).approve(address(infraredVault), amount);
infraredVault.stake(amount);

// Check earned rewards
IInfraredVault.RewardData[] memory rTs = infraredVault.getUserRewardsEarned(user);

// Harvest rewards
infraredVault.getReward();

// Withdraw assets and harvest remaining rewards
infraredVault.exit();

Contents

• libraries
• BribeCollector
• Infrared
• InfraredBGT
• InfraredDistributor
• InfraredUpgradeable
• InfraredVault
• MultiRewards
• RED
• WrappedVault

Contents

• ConfigTypes
• RewardsLib
• ValidatorManagerLib
• ValidatorTypes
• VaultManagerLib

ConfigTypes

Git Source

Enums

FeeType

Fee type enum for determining rates to charge on reward distribution.

enum FeeType {
    HarvestOperatorFeeRate,
    HarvestOperatorProtocolRate,
    HarvestVaultFeeRate,
    HarvestVaultProtocolRate,
    HarvestBribesFeeRate,
    HarvestBribesProtocolRate,
    HarvestBoostFeeRate,
    HarvestBoostProtocolRate
}

RewardsLib

Git Source

State Variables

RATE_UNIT

RED mint rate in hundredths of 1 bip

Used as the denominator when calculating IRED minting (1e6)

uint256 internal constant RATE_UNIT = 1e6;

WEIGHT_UNIT

Weight units when partitioning reward amounts in hundredths of 1 bip

Used as the denominator when calculating weighted distributions (1e6)

uint256 internal constant WEIGHT_UNIT = 1e6;

FEE_UNIT

Protocol fee rate in hundredths of 1 bip

Used as the denominator when calculating protocol fees (1e6)

uint256 internal constant FEE_UNIT = 1e6;

Functions

chargedFeesOnRewards

Calculates how fees are split between protocol, voters, and the recipient.

function chargedFeesOnRewards(
    RewardsStorage storage,
    uint256 _amt,
    uint256 _feeTotal,
    uint256 _feeProtocol
)
    external
    pure
    returns (uint256 amtRecipient, uint256 amtVoter, uint256 amtProtocol);

_chargedFeesOnRewards

function _chargedFeesOnRewards(
    uint256 _amt,
    uint256 _feeTotal,
    uint256 _feeProtocol
)
    internal
    pure
    returns (uint256 amtRecipient, uint256 amtVoter, uint256 amtProtocol);

_distributeFeesOnRewards

function _distributeFeesOnRewards(
    mapping(address => uint256) storage protocolFeeAmounts,
    address _voter,
    address _token,
    uint256 _amtVoter,
    uint256 _amtProtocol
) internal;

harvestBase

function harvestBase(address bgt, address ibgt, address ibera)
    external
    returns (uint256 bgtAmt);

harvestVault

function harvestVault(
    RewardsStorage storage $,
    IInfraredVault vault,
    address bgt,
    address ibgt,
    address voter,
    address red,
    uint256 rewardsDuration
) external returns (uint256 bgtAmt);

harvestBribes

function harvestBribes(
    RewardsStorage storage $,
    address wbera,
    address collector,
    address[] memory _tokens,
    bool[] memory whitelisted
) external returns (address[] memory tokens, uint256[] memory _amounts);

collectBribesInWBERA

function collectBribesInWBERA(
    RewardsStorage storage $,
    uint256 _amount,
    address wbera,
    address ibera,
    address ibgtVault,
    address voter,
    uint256 rewardsDuration
) external returns (uint256 amtInfraredBERA, uint256 amtIbgtVault);

harvestBoostRewards

function harvestBoostRewards(
    RewardsStorage storage $,
    address bgt,
    address ibgtVault,
    address voter,
    uint256 rewardsDuration
) external returns (address _vault, address _token, uint256 _amount);

harvestOperatorRewards

function harvestOperatorRewards(
    RewardsStorage storage $,
    address ibera,
    address voter,
    address distributor
) external returns (uint256 _amt);

_handleTokenRewardsForVault

Handles non-InfraredBGT token rewards to the vault.

function _handleTokenRewardsForVault(
    RewardsStorage storage $,
    IInfraredVault _vault,
    address _token,
    address voter,
    uint256 _amount,
    uint256 _feeTotal,
    uint256 _feeProtocol,
    uint256 rewardsDuration
) internal;

Parameters

_handleTokenBribesForReceiver

Handles non-InfraredBGT token bribe rewards to a non-vault receiver address.

Does not take protocol fee on bribe coin, as taken on bribe collector payout token in eventual callback.

function _handleTokenBribesForReceiver(
    RewardsStorage storage,
    address _recipient,
    address _token,
    uint256 _amount
) internal;

Parameters

_handleRewardsForOperators

Handles BGT base rewards supplied to validator distributor.

function _handleRewardsForOperators(
    RewardsStorage storage $,
    address ibera,
    address voter,
    address distributor,
    uint256 _iBERAShares,
    uint256 _feeTotal,
    uint256 _feeProtocol
) internal returns (uint256 _amt);

Parameters

delegateBGT

function delegateBGT(RewardsStorage storage, address _delegatee, address bgt)
    external;

updateInfraredBERABribesWeight

function updateInfraredBERABribesWeight(
    RewardsStorage storage $,
    uint256 _weight
) external;

updateFee

function updateFee(
    RewardsStorage storage $,
    ConfigTypes.FeeType _t,
    uint256 _fee
) external;

claimProtocolFees

function claimProtocolFees(
    RewardsStorage storage $,
    address _to,
    address _token,
    uint256 _amount
) external;

getBGTBalance

function getBGTBalance(RewardsStorage storage, address bgt)
    external
    view
    returns (uint256);

_getBGTBalance

function _getBGTBalance(address bgt) internal view returns (uint256);

updateRedMintRate

function updateRedMintRate(RewardsStorage storage $, uint256 _iredMintRate)
    external;

Events

RedNotMinted

Emitted when Red cannot be minted during a harvest because of pause

event RedNotMinted(uint256 amount);

Structs

RewardsStorage

struct RewardsStorage {
    mapping(address => uint256) protocolFeeAmounts;
    uint256 redMintRate;
    uint256 collectBribesWeight;
    mapping(uint256 => uint256) fees;
}

ValidatorManagerLib

Git Source

Functions

isValidator

function isValidator(ValidatorStorage storage $, bytes memory pubkey)
    external
    view
    returns (bool);

_getValidatorId

Gets the validator ID for associated CL pubkey

function _getValidatorId(bytes memory pubkey) internal pure returns (bytes32);

Parameters

addValidators

function addValidators(
    ValidatorStorage storage $,
    address distributor,
    ValidatorTypes.Validator[] memory _validators
) external;

removeValidators

function removeValidators(
    ValidatorStorage storage $,
    address distributor,
    bytes[] memory _pubkeys
) external;

replaceValidator

function replaceValidator(
    ValidatorStorage storage $,
    address distributor,
    bytes calldata _current,
    bytes calldata _new
) external;

queueBoosts

function queueBoosts(
    ValidatorStorage storage $,
    address bgt,
    address ibgt,
    bytes[] memory _pubkeys,
    uint128[] memory _amts
) external;

cancelBoosts

function cancelBoosts(
    ValidatorStorage storage $,
    address bgt,
    bytes[] memory _pubkeys,
    uint128[] memory _amts
) external;

activateBoosts

function activateBoosts(
    ValidatorStorage storage $,
    address bgt,
    bytes[] memory _pubkeys
) external;

queueDropBoosts

function queueDropBoosts(
    ValidatorStorage storage $,
    address bgt,
    bytes[] memory _pubkeys,
    uint128[] memory _amts
) external;

cancelDropBoosts

function cancelDropBoosts(
    ValidatorStorage storage $,
    address bgt,
    bytes[] memory _pubkeys,
    uint128[] memory _amts
) external;

dropBoosts

function dropBoosts(
    ValidatorStorage storage $,
    address bgt,
    bytes[] memory _pubkeys
) external;

infraredValidators

function infraredValidators(ValidatorStorage storage $, address distributor)
    external
    view
    returns (ValidatorTypes.Validator[] memory validators);

numInfraredValidators

function numInfraredValidators(ValidatorStorage storage $)
    external
    view
    returns (uint256);

_getValidatorAddress

function _getValidatorAddress(
    ValidatorStorage storage,
    address distributor,
    bytes memory pubkey
) internal view returns (address);

Structs

ValidatorStorage

struct ValidatorStorage {
    EnumerableSet.Bytes32Set validatorIds;
    mapping(bytes32 => bytes) validatorPubkeys;
}

ValidatorTypes

Git Source

Structs

Validator

Validator information for validator set

struct Validator {
    bytes pubkey;
    address addr;
}

VaultManagerLib

Git Source

Functions

notPaused

Ensures that new vaults can only be registered while the register vaults are not paused

modifier notPaused(VaultStorage storage $);

registerVault

Registers a new vault for a specific asset.

function registerVault(VaultStorage storage $, address asset)
    external
    notPaused($)
    returns (address);

setVaultRegistrationPauseStatus

Sets new vault registration paused or not

function setVaultRegistrationPauseStatus(VaultStorage storage $, bool pause)
    external;

Parameters

toggleVault

Toggles the pause status of a specific vault.

function toggleVault(VaultStorage storage $, address asset) external;

updateWhitelistedRewardTokens

Updates the whitelist status of a reward token.

function updateWhitelistedRewardTokens(
    VaultStorage storage $,
    address token,
    bool whitelisted
) external;

addReward

function addReward(
    VaultStorage storage $,
    address _stakingToken,
    address _rewardsToken,
    uint256 _rewardsDuration
) external;

addIncentives

function addIncentives(
    VaultStorage storage $,
    address _stakingToken,
    address _rewardsToken,
    uint256 _amount
) external;

updateRewardsDuration

Updates the global rewards duration for new vaults.

function updateRewardsDuration(VaultStorage storage $, uint256 newDuration)
    external;

isWhitelisted

Checks if a token is whitelisted as a reward token.

function isWhitelisted(VaultStorage storage $, address token)
    public
    view
    returns (bool);

recoverERC20FromVault

function recoverERC20FromVault(
    VaultStorage storage $,
    address _asset,
    address _to,
    address _token,
    uint256 _amount
) external;

updateRewardsDurationForVault

function updateRewardsDurationForVault(
    VaultStorage storage $,
    address _stakingToken,
    address _rewardsToken,
    uint256 _rewardsDuration
) external;

claimLostRewardsOnVault

function claimLostRewardsOnVault(VaultStorage storage $, address _asset)
    external;

Structs

VaultStorage

struct VaultStorage {
    bool pausedVaultRegistration;
    mapping(address => IInfraredVault) vaultRegistry;
    EnumerableSet.AddressSet whitelistedRewardTokens;
    uint256 rewardsDuration;
}

BribeCollector

Git Source

Inherits: InfraredUpgradeable, IBribeCollector

The Bribe Collector contract is responsible for collecting bribes from Berachain rewards vaults and auctioning them for a Payout token which then is distributed among Infrared validators.

This contract is forked from Berachain POL which is forked from Uniswap V3 Factory Owner contract. https://github.com/uniswapfoundation/UniStaker/blob/main/src/V3FactoryOwner.sol

State Variables

payoutToken

Token used for fee payments when claiming bribes

address public payoutToken;

payoutAmount

The amount of payout token that is required to claim POL bribes for all tokens

This works as first come first serve basis. whoever pays this much amount of the payout amount first will get the fees

uint256 public payoutAmount;

Functions

constructor

constructor(address _infrared) InfraredUpgradeable(_infrared);

initialize

function initialize(address _gov, address _payoutToken, uint256 _payoutAmount)
    external
    initializer;

setPayoutAmount

Update the payout amount to a new value. Must be called by governor

function setPayoutAmount(uint256 _newPayoutAmount) external onlyGovernor;

Parameters

claimFees

Claims accumulated bribes in exchange for payout token

Caller must approve payoutAmount of payout token to this contract.

function claimFees(
    address _recipient,
    address[] calldata _feeTokens,
    uint256[] calldata _feeAmounts
) external;

Parameters

Infrared

Git Source

Inherits: InfraredUpgradeable, IInfrared

Provides core functionalities for managing validators, vaults, and reward distribution in the Infrared protocol.

Serves as the main entry point for interacting with the Infrared protocol

The contract is upgradeable, ensuring flexibility for governance-led upgrades and chain compatibility.

State Variables

_bgt

The BGT token contract reference

Immutable IBerachainBGT instance of the BGT token

IBerachainBGT internal _bgt;

ibgt

The InfraredBGT liquid staked token

InfraredBGT public ibgt;

rewardsFactory

The Berachain rewards vault factory address

IBerachainRewardsVaultFactory public rewardsFactory;

chef

The Berachain chef contract for distributing validator rewards

IBeraChef public chef;

wbera

Wrapped bera

IWBERA public wbera;

honey

Honey ERC20 token

ERC20 public honey;

collector

bribe collector contract

IBribeCollector public collector;

distributor

Infrared distributor for BGT rewards to validators

IInfraredDistributor public distributor;

voter

IRED voter

IVoter public voter;

ibera

collects all iBERA realted fees and revenue

IInfraredBERA public ibera;

red

The RED token

IRED public red;

ibgtVault

The InfraredBGT vault

IInfraredVault public ibgtVault;

VALIDATOR_STORAGE_LOCATION

Upgradeable ERC-7201 storage for Validator lib

keccak256(abi.encode(uint256(keccak256(bytes("infrared.validatorStorage"))) - 1)) & ~bytes32(uint256(0xff));

bytes32 public constant VALIDATOR_STORAGE_LOCATION =
    0x8ea5a3cc3b9a6be40b16189aeb1b6e6e61492e06efbfbe10619870b5bc1cc500;

VAULT_STORAGE_LOCATION

Upgradeable ERC-7201 storage for Vault lib

keccak256(abi.encode(uint256(keccak256(bytes("infrared.vaultStorage"))) - 1)) & ~bytes32(uint256(0xff));

bytes32 public constant VAULT_STORAGE_LOCATION =
    0x1bb2f1339407e6d63b93b8b490a9d43c5651f6fc4327c66addd5939450742a00;

REWARDS_STORAGE_LOCATION

Upgradeable ERC-7201 storage for Rewards lib

keccak256(abi.encode(uint256(keccak256(bytes("infrared.rewardsStorage"))) - 1)) & ~bytes32(uint256(0xff));

bytes32 public constant REWARDS_STORAGE_LOCATION =
    0xad12e6d08cc0150709acd6eed0bf697c60a83227922ab1d254d1ca4d3072ca00;

Functions

_validatorStorage

function _validatorStorage()
    internal
    pure
    returns (ValidatorManagerLib.ValidatorStorage storage vs);

_vaultStorage

function _vaultStorage()
    internal
    pure
    returns (VaultManagerLib.VaultStorage storage vs);

_rewardsStorage

function _rewardsStorage()
    internal
    pure
    returns (RewardsLib.RewardsStorage storage rs);

onlyCollector

Ensures that only the collector contract can call the function Reverts if the caller is not the collector

modifier onlyCollector();

constructor

constructor() InfraredUpgradeable(address(0));

initialize

function initialize(InitializationData calldata data) external initializer;

_validateInitializationData

function _validateInitializationData(InitializationData memory data)
    internal
    pure;

_initializeCoreContracts

function _initializeCoreContracts(InitializationData memory data) internal;

registerVault

Registers a new vault for a given asset

Infrared.sol must be admin over MINTER_ROLE on InfraredBGT to grant minter role to deployed vault

Note: emits: NewVault with the caller, asset address, and new vault address.

function registerVault(address _asset)
    external
    returns (IInfraredVault vault);

Parameters

Returns

addReward

Adds a new reward token to a specific staking vault

Only callable by governance when contract is initialized

Note: error: ZeroAmount if _rewardsDuration is 0

function addReward(
    address _stakingToken,
    address _rewardsToken,
    uint256 _rewardsDuration
) external onlyGovernor;

Parameters

addIncentives

Adds reward incentives to a specific staking vault

Transfers reward tokens from caller to this contract, then notifies vault of new rewards

Notes:

• error: ZeroAmount if _amount is 0

• access: Callable when contract is initialized

• security: Requires caller to have approved this contract to spend _rewardsToken

function addIncentives(
    address _stakingToken,
    address _rewardsToken,
    uint256 _amount
) external;

Parameters

updateWhiteListedRewardTokens

Updates the whitelist status of a reward token

function updateWhiteListedRewardTokens(address _token, bool _whitelisted)
    external
    onlyGovernor;

Parameters

updateRewardsDuration

Sets the new duration for reward distributions in InfraredVaults

Only callable by governance

function updateRewardsDuration(uint256 _rewardsDuration)
    external
    onlyGovernor;

Parameters

updateRewardsDurationForVault

Updates the rewards duration for a specific reward token on a specific vault

Only callable by governance

function updateRewardsDurationForVault(
    address _stakingToken,
    address _rewardsToken,
    uint256 _rewardsDuration
) external onlyGovernor;

Parameters

toggleVault

Pauses staking functionality on a specific vault

Only callable by governance, will revert if vault doesn't exist

function toggleVault(address _asset) external onlyGovernor;

Parameters

claimLostRewardsOnVault

Claims lost rewards on a specific vault

Only callable by governance, will revert if vault doesn't exist

function claimLostRewardsOnVault(address _asset) external onlyGovernor;

Parameters

recoverERC20

Recovers ERC20 tokens sent accidentally to the contract

function recoverERC20(address _to, address _token, uint256 _amount)
    external
    onlyGovernor;

Parameters

recoverERC20FromVault

Recover ERC20 tokens from a vault.

function recoverERC20FromVault(
    address _asset,
    address _to,
    address _token,
    uint256 _amount
) external onlyGovernor;

Parameters

delegateBGT

Delegates BGT votes to _delegatee address.

function delegateBGT(address _delegatee) external onlyGovernor;

Parameters

updateInfraredBERABribesWeight

Updates the weight for iBERA bribes

function updateInfraredBERABribesWeight(uint256 _weight)
    external
    onlyGovernor;

Parameters

updateFee

Updates the fee rate charged on different harvest functions

Fee rate in units of 1e6 or hundredths of 1 bip

function updateFee(ConfigTypes.FeeType _t, uint256 _fee)
    external
    onlyGovernor;

Parameters

claimProtocolFees

Claims accumulated protocol fees in contract

function claimProtocolFees(address _to, address _token, uint256 _amount)
    external
    onlyGovernor;

Parameters

setIBGT

Sets the address of the iBGT contract

Infrared must be granted MINTER_ROLE on IBGT to set the address

function setIBGT(address _ibgt) external;

Parameters

setRed

Sets the address of the RED contract

Infrared must be granted MINTER_ROLE on RED to set the address

function setRed(address _red) external;

Parameters

updateRedMintRate

Updates the mint rate for RED

function updateRedMintRate(uint256 _redMintRate) external onlyGovernor;

Parameters

chargedFeesOnRewards

function chargedFeesOnRewards(
    uint256 _amt,
    uint256 _feeTotal,
    uint256 _feeProtocol
)
    public
    view
    returns (uint256 amtRecipient, uint256 amtVoter, uint256 amtProtocol);

harvestBase

Claims all the BGT base and commission rewards minted to this contract for validators.

function harvestBase() public;

harvestVault

Claims all the BGT rewards for the vault associated with the given staking token.

function harvestVault(address _asset) external;

Parameters

harvestBribes

Claims all the bribes rewards in the contract forwarded from Berachain POL.

function harvestBribes(address[] calldata _tokens) external;

Parameters

collectBribes

Collects bribes from bribe collector and distributes to wiBERA and iBGT Infrared vaults.

function collectBribes(address _token, uint256 _amount)
    external
    onlyCollector;

harvestOperatorRewards

Credits all accumulated rewards to the operator

function harvestOperatorRewards() public;

harvestBoostRewards

Claims all the BGT staker rewards from boosting validators.

Sends rewards to iBGT vault.

function harvestBoostRewards() external;

addValidators

Adds validators to the set of InfraredValidators.

function addValidators(ValidatorTypes.Validator[] calldata _validators)
    external
    onlyGovernor;

Parameters

removeValidators

Removes validators from the set of InfraredValidators.

function removeValidators(bytes[] calldata _pubkeys) external onlyGovernor;

Parameters

replaceValidator

Replaces a validator in the set of InfraredValidators.

function replaceValidator(bytes calldata _current, bytes calldata _new)
    external
    onlyGovernor;

Parameters

queueNewCuttingBoard

Queues a new cutting board on BeraChef for reward weight distribution for validator

function queueNewCuttingBoard(
    bytes calldata _pubkey,
    uint64 _startBlock,
    IBeraChef.Weight[] calldata _weights
) external onlyKeeper;

Parameters

queueBoosts

Queue _amts of tokens to _validators for boosts.

function queueBoosts(bytes[] calldata _pubkeys, uint128[] calldata _amts)
    external
    onlyKeeper;

Parameters

cancelBoosts

Removes _amts from previously queued boosts to _validators.

_pubkeys need not be in the current validator set in case just removed but need to cancel.

function cancelBoosts(bytes[] calldata _pubkeys, uint128[] calldata _amts)
    external
    onlyKeeper;

Parameters

activateBoosts

Activates queued boosts for _pubkeys.

function activateBoosts(bytes[] calldata _pubkeys) external;

Parameters

queueDropBoosts

Queues a drop boost of the validators removing an amount of BGT for sender.

Reverts if user does not have enough boosted balance to cover amount.

function queueDropBoosts(bytes[] calldata _pubkeys, uint128[] calldata _amts)
    external
    onlyKeeper;

Parameters

cancelDropBoosts

Cancels a queued drop boost of the validator removing an amount of BGT for sender.

function cancelDropBoosts(bytes[] calldata _pubkeys, uint128[] calldata _amts)
    external
    onlyKeeper;

Parameters

dropBoosts

Drops an amount of BGT from an existing boost of validators by user.

function dropBoosts(bytes[] calldata _pubkeys) external;

Parameters

infraredValidators

Gets the set of infrared validator pubkeys.

function infraredValidators()
    public
    view
    virtual
    returns (ValidatorTypes.Validator[] memory validators);

Returns

numInfraredValidators

Gets the number of infrared validators in validator set.

function numInfraredValidators() external view returns (uint256);

Returns

isInfraredValidator

Checks if a validator is an infrared validator.

function isInfraredValidator(bytes calldata _validator)
    public
    view
    returns (bool);

Parameters

Returns

getBGTBalance

Gets the BGT balance for this contract

function getBGTBalance() public view returns (uint256);

Returns

whitelistedRewardTokens

Mapping of tokens that are whitelisted to be used as rewards or accepted as bribes

serves as central source of truth for whitelisted reward tokens for all Infrared contracts

function whitelistedRewardTokens(address token) public view returns (bool);

vaultRegistry

Mapping of staking token addresses to their corresponding InfraredVault

Each staking token can only have one vault

function vaultRegistry(address _stakingToken)
    public
    view
    returns (IInfraredVault vault);

setVaultRegistrationPauseStatus

Sets new vault registration paused or not

function setVaultRegistrationPauseStatus(bool pause) external onlyGovernor;

Parameters

rewardsDuration

The rewards duration

Used as gloabl variabel to set the rewards duration for all new reward tokens on InfraredVaults

function rewardsDuration() public view returns (uint256 duration);

Returns

fees

Protocol fee rates to charge for various harvest function distributions

function fees(uint256 t) public view override returns (uint256);

Parameters

Returns

protocolFeeAmounts

The unclaimed Infrared protocol fees of token accumulated by contract

function protocolFeeAmounts(address _token) external view returns (uint256);

Parameters

Returns

receive

receive() external payable;

Structs

InitializationData

struct InitializationData {
    address _gov;
    address _keeper;
    address __bgt;
    address _rewardsFactory;
    address _chef;
    address payable _wbera;
    address _honey;
    address _collector;
    address _distributor;
    address _voter;
    address _iBERA;
    uint256 _rewardsDuration;
}

InfraredBGT

Git Source

Inherits: ERC20PresetMinterPauser

This contract is the InfraredBGT token.

State Variables

bgt

address public immutable bgt;

Functions

constructor

constructor(address _bgt, address _admin, address _minter, address _pauser)
    ERC20PresetMinterPauser("Infrared BGT", "iBGT", _admin, _minter, _pauser);

Errors

ZeroAddress

error ZeroAddress();

InfraredDistributor

Git Source

Inherits: InfraredUpgradeable, IInfraredDistributor

A contract for distributing rewards in a single ERC20 token (iBERA) to validators

State Variables

token

Token used for reward distributions

ERC20 public token;

amountsCumulative

Tracks reward amount accumulation per validator

uint256 public amountsCumulative;

_snapshots

mapping(bytes32 pubkeyHash => Snapshot) internal _snapshots;

_validators

mapping(bytes32 pubkeyHash => address) internal _validators;

Functions

constructor

constructor(address _infrared) InfraredUpgradeable(_infrared);

initialize

function initialize(address _gov, address _token) external initializer;

add

Register new validator for rewards

Only callable by Infrared contract

Notes:

• access-control: Requires INFRARED_ROLE

• error: ValidatorAlreadyExists if validator already registered

function add(bytes calldata pubkey, address validator) external onlyInfrared;

Parameters

remove

Removes validator from reward-eligible set

Only callable by Infrared contract

Note: access-control: Requires INFRARED_ROLE

function remove(bytes calldata pubkey) external onlyInfrared;

Parameters

purge

Purges validator from registry completely

Only possible after all rewards are claimed

Note: error: ClaimableRewardsExist if unclaimed rewards remain

function purge(bytes calldata pubkey) external;

Parameters

notifyRewardAmount

Distributes new commission rewards to validator set

Note: error: ZeroAmount if amount is 0

function notifyRewardAmount(uint256 amount) external;

Parameters

claim

Claims outstanding commission rewards

Note: error: InvalidValidator if caller not authorized

function claim(bytes calldata pubkey, address recipient) external;

Parameters

getSnapshot

Get validator's reward snapshots

Returns (0,0) if validator doesn't exist

function getSnapshot(bytes calldata pubkey)
    external
    view
    returns (uint256 amountCumulativeLast, uint256 amountCumulativeFinal);

Parameters

Returns

getValidator

Get validator's registered claim address

function getValidator(bytes calldata pubkey) external view returns (address);

Parameters

Returns

InfraredUpgradeable

Git Source

Inherits: Upgradeable

This contract provides base upgradeability functionality for Infrared.

State Variables

infrared

Infrared coordinator contract

IInfrared public immutable infrared;

Functions

onlyInfrared

modifier onlyInfrared();

constructor

constructor(address _infrared);

__InfraredUpgradeable_init

function __InfraredUpgradeable_init() internal onlyInitializing;

InfraredVault

Git Source

Inherits: MultiRewards, IInfraredVault

This contract is the vault for staking tokens, and receiving rewards from the Proof of Liquidity protocol.

This contract uses the MultiRewards contract to distribute rewards to vault stakers, this is taken from curve.fi. (inspired by Synthetix).

Does not support staking tokens with non-standard ERC20 transfer tax behavior.

State Variables

MAX_NUM_REWARD_TOKENS

Maximum number of reward tokens that can be supported

Limited to prevent gas issues with reward calculations

uint256 public constant MAX_NUM_REWARD_TOKENS = 10;

infrared

The infrared contract address acts a vault factory and coordinator

address public immutable infrared;

rewardsVault

IBerachainRewardsVault public immutable rewardsVault;

Functions

onlyInfrared

Modifier to check that the caller is infrared contract

modifier onlyInfrared();

constructor

constructor(address _stakingToken, uint256 _rewardsDuration)
    MultiRewards(_stakingToken);

_createRewardsVaultIfNecessary

Gets or creates the berachain rewards vault for given staking token

function _createRewardsVaultIfNecessary(
    address _infrared,
    address _stakingToken
) private returns (IBerachainRewardsVault);

Parameters

Returns

onStake

Transfers to berachain low level module on staking of LP tokens with the vault after transferring tokens in

function onStake(uint256 amount) internal override;

Parameters

onWithdraw

Redeems from berachain low level module on withdraw of LP tokens from the vault before transferring tokens out

function onWithdraw(uint256 amount) internal override;

Parameters

onReward

hook called after the reward is claimed to harvest the rewards from the berachain rewards vault

function onReward() internal override;

updateRewardsDuration

Updates reward duration for a specific reward token

Only callable by Infrared contract

Note: access-control: Requires INFRARED_ROLE

function updateRewardsDuration(address _rewardsToken, uint256 _rewardsDuration)
    external
    onlyInfrared;

Parameters

togglePause

Toggles pause state of the vault

Affects all vault operations when paused

Note: access-control: Requires INFRARED_ROLE

function togglePause() external onlyInfrared;

addReward

Adds a new reward token to the vault

Cannot exceed maximum number of reward tokens

Note: access-control: Requires INFRARED_ROLE

function addReward(address _rewardsToken, uint256 _rewardsDuration)
    external
    onlyInfrared;

Parameters

notifyRewardAmount

Notifies the vault of newly added rewards

Updates internal reward rate calculations

function notifyRewardAmount(address _rewardToken, uint256 _reward)
    external
    onlyInfrared;

Parameters

recoverERC20

Recovers accidentally sent tokens

Cannot recover staking token or active reward tokens

function recoverERC20(address _to, address _token, uint256 _amount)
    external
    onlyInfrared;

Parameters

getAllRewardTokens

Returns all reward tokens

function getAllRewardTokens() external view returns (address[] memory);

Returns

getAllRewardsForUser

Returns all rewards for a user

function getAllRewardsForUser(address _user)
    external
    view
    returns (UserReward[] memory);

Parameters

Returns

MultiRewards

Git Source

Inherits: ReentrancyGuard, Pausable, IMultiRewards

Fork of https://github.com/curvefi/multi-rewards with hooks on stake/withdraw of LP tokens

State Variables

stakingToken

The token that users stake to earn rewards

This is the base token that users deposit into the contract

ERC20 public immutable stakingToken;

rewardData

Stores reward-related data for each reward token

Maps reward token addresses to their Reward struct containing distribution parameters

mapping(address => Reward) public override rewardData;

rewardTokens

Array of all reward token addresses

Used to iterate through all reward tokens when updating or claiming rewards

address[] public rewardTokens;

userRewardPerTokenPaid

Tracks the reward per token paid to each user for each reward token

Maps user address to reward token address to amount already paid Used to calculate new rewards since last claim

mapping(address => mapping(address => uint256)) public userRewardPerTokenPaid;

rewards

Tracks the unclaimed rewards for each user for each reward token

Maps user address to reward token address to unclaimed amount

mapping(address => mapping(address => uint256)) public rewards;

_totalSupply

The total amount of staking tokens in the contract

Used to calculate rewards per token

uint256 internal _totalSupply;

_balances

Maps user addresses to their staked token balance

Internal mapping used to track individual stake amounts

mapping(address => uint256) internal _balances;

Functions

updateReward

Updates the reward for the given account before executing the function body.

modifier updateReward(address account);

Parameters

constructor

Constructs the MultiRewards contract.

constructor(address _stakingToken);

Parameters

totalSupply

Returns the total amount of staked tokens in the contract

function totalSupply() external view returns (uint256);

Returns

balanceOf

Returns the balance of staked tokens for the given account

function balanceOf(address account) external view returns (uint256 _balance);

Parameters

Returns

lastTimeRewardApplicable

Calculates the last time reward is applicable for a given rewards token

function lastTimeRewardApplicable(address _rewardsToken)
    public
    view
    returns (uint256);

Parameters

Returns

rewardPerToken

Calculates the reward per token for a given rewards token

function rewardPerToken(address _rewardsToken) public view returns (uint256);

Parameters

Returns

earned

Calculates the earned rewards for a given account and rewards token

function earned(address account, address _rewardsToken)
    public
    view
    returns (uint256);

Parameters

Returns

getRewardForDuration

Calculates the total reward for the duration of a given rewards token

function getRewardForDuration(address _rewardsToken)
    external
    view
    returns (uint256);

Parameters

Returns

stake

Stakes tokens into the contract

Transfers amount of staking tokens from the user to this contract

function stake(uint256 amount)
    external
    nonReentrant
    whenNotPaused
    updateReward(msg.sender);

Parameters

onStake

Hook called in the stake function after transfering staking token in

function onStake(uint256 amount) internal virtual;

Parameters

withdraw

Withdraws staked tokens from the contract

Transfers amount of staking tokens back to the user

function withdraw(uint256 amount)
    public
    nonReentrant
    updateReward(msg.sender);

Parameters

onWithdraw

Hook called in withdraw function before transferring staking token out

function onWithdraw(uint256 amount) internal virtual;

Parameters

getRewardForUser

Claims all pending rewards for a specified user

Iterates through all reward tokens and transfers any accrued rewards to the user

function getRewardForUser(address _user)
    public
    nonReentrant
    updateReward(_user);

Parameters

onReward

Hook called in getRewardForUser function

function onReward() internal virtual;

getReward

Claims all pending rewards for the caller

Transfers all accrued rewards to the caller

function getReward() public;

exit

Withdraws all staked tokens and claims pending rewards

Combines withdraw and getReward operations

function exit() external;

_addReward

Adds a reward token to the contract.

function _addReward(
    address _rewardsToken,
    address _rewardsDistributor,
    uint256 _rewardsDuration
) internal;

Parameters

_notifyRewardAmount

Notifies the contract that reward tokens is being sent to the contract.

function _notifyRewardAmount(address _rewardsToken, uint256 reward)
    internal
    whenNotPaused
    updateReward(address(0));

Parameters

_recoverERC20

Recovers ERC20 tokens sent to the contract.

Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders

function _recoverERC20(address to, address tokenAddress, uint256 tokenAmount)
    internal;

Parameters

_setRewardsDuration

Updates the reward duration for a reward token.

function _setRewardsDuration(address _rewardsToken, uint256 _rewardsDuration)
    internal;

Parameters

RED

Git Source

Inherits: ERC20PresetMinterPauser

This contract is the RED token.

State Variables

ibgt

address public immutable ibgt;

infrared

address public immutable infrared;

Functions

constructor

constructor(
    address _ibgt,
    address _infrared,
    address _admin,
    address _minter,
    address _pauser
)
    ERC20PresetMinterPauser(
        "Infared Governance Token",
        "RED",
        _admin,
        _minter,
        _pauser
    );

Errors

ZeroAddress

error ZeroAddress();

WrappedVault

Git Source

Inherits: ERC4626

A wrapper vault built on ERC4626 to facilitate staking operations and reward distribution through the Infrared protocol. Each staking token has a corresponding wrapped vault.

deploy 1 wrapped vault per staking token

State Variables

rewardDistributor

Address of the reward distributor, typically a multisig.

address public immutable rewardDistributor;

iVault

Instance of the associated InfraredVault for staking.

InfraredVault public immutable iVault;

deadShares

Inflation attack prevention

uint256 internal constant deadShares = 1e3;

Functions

constructor

Initializes a new WrappedVault contract for a specific staking token.

constructor(
    address _rewardDistributor,
    address _infrared,
    address _stakingToken,
    string memory _name,
    string memory _symbol
) ERC4626(ERC20(_stakingToken), _name, _symbol);

Parameters

totalAssets

Returns the total assets managed by the wrapped vault.

Overrides the ERC4626 totalAssets function to integrate with the InfraredVault balance.

function totalAssets() public view virtual override returns (uint256);

Returns

beforeWithdraw

Hook called before withdrawal operations.

This function ensures that the requested amount of staking tokens is withdrawn from the InfraredVault before being transferred to the user.

function beforeWithdraw(uint256 assets, uint256) internal virtual override;

Parameters

afterDeposit

Hook called after deposit operations.

This function stakes the deposited tokens into the InfraredVault.

function afterDeposit(uint256 assets, uint256) internal virtual override;

Parameters

claimRewards

Claims rewards from the InfraredVault and transfers them to the reward distributor.

Only rewards other than the staking token itself are transferred.

function claimRewards() external;

Events

RewardClaimed

Event emitted when reward tokens claimed

event RewardClaimed(address indexed token, uint256 amount);

Contents

• IBerachainBGT
• IBerachainBGTStaker
• IBribeCollector
• IERC20Mintable
• IInfrared
• IInfraredBERA
• IInfraredBERAClaimor
• IInfraredBERADepositor
• IInfraredBERAFeeReceivor
• IInfraredBERAWithdrawor
• IInfraredBGT
• IInfraredDistributor
• IInfraredUpgradeable
• IInfraredVault
• IMultiRewards
• IRED
• IWBERA

IBerachainBGT

Git Source

Inherits: IBGT

IBerachainBGTStaker

Git Source

Inherits: IBGTStaker

Functions

rewardToken

Temp override of interface to include left out reward token

function rewardToken() external view returns (address);

IBribeCollector

Git Source

Inherits: IPOLErrors

Functions

payoutToken

Token used for fee payments when claiming bribes

function payoutToken() external view returns (address);

Returns

payoutAmount

The amount of payout token that is required to claim POL bribes for all tokens

This works as first come first serve basis. whoever pays this much amount of the payout amount first will get the fees

function payoutAmount() external view returns (uint256);

setPayoutAmount

Update the payout amount to a new value. Must be called by governor

function setPayoutAmount(uint256 _newPayoutAmount) external;

Parameters

claimFees

Claims accumulated bribes in exchange for payout token

Caller must approve payoutAmount of payout token to this contract.

function claimFees(
    address _recipient,
    address[] calldata _feeTokens,
    uint256[] calldata _feeAmounts
) external;

Parameters

Events

PayoutAmountSet

Emitted when the payout amount is updated by the governor

event PayoutAmountSet(
    uint256 indexed oldPayoutAmount, uint256 indexed newPayoutAmount
);

Parameters

FeesClaimed

Emitted when the fees are claimed

event FeesClaimed(
    address indexed caller,
    address indexed recipient,
    address indexed feeToken,
    uint256 amount
);

Parameters

IERC20Mintable

Git Source

Inherits: IERC20

Functions

MINTER_ROLE

function MINTER_ROLE() external view returns (bytes32);

mint

function mint(address to, uint256 amount) external;

IInfrared

Git Source

Functions

whitelistedRewardTokens

Checks if a token is a whitelisted reward token

function whitelistedRewardTokens(address _token) external view returns (bool);

Parameters

Returns

vaultRegistry

Returns the infrared vault address for a given staking token

function vaultRegistry(address _asset) external view returns (IInfraredVault);

Parameters

Returns

ibgt

The InfraredBGT liquid staked token

function ibgt() external view returns (InfraredBGT);

Returns

rewardsFactory

The Berachain rewards vault factory address

function rewardsFactory()
    external
    view
    returns (IBerachainRewardsVaultFactory);

Returns

chef

The Berachain chef contract for distributing validator rewards

function chef() external view returns (IBeraChef);

Returns

ibgtVault

The InfraredBGT vault

function ibgtVault() external view returns (IInfraredVault);

Returns

protocolFeeAmounts

The unclaimed Infrared protocol fees of token accumulated by contract

function protocolFeeAmounts(address token) external view returns (uint256);

Parameters

Returns

fees

Protocol fee rates to charge for various harvest function distributions

function fees(uint256 i) external view returns (uint256);

Parameters

Returns

wbera

Wrapped bera

function wbera() external view returns (IWBERA);

Returns

honey

Honey ERC20 token

function honey() external view returns (ERC20);

Returns

collector

bribe collector contract

function collector() external view returns (IBribeCollector);

Returns

distributor

Infrared distributor for BGT rewards to validators

function distributor() external view returns (IInfraredDistributor);

Returns

voter

IRED voter

function voter() external view returns (IVoter);

Returns

ibera

collects all iBERA realted fees and revenue

function ibera() external view returns (IInfraredBERA);

Returns

red

The RED token

function red() external view returns (IRED);

Returns

rewardsDuration

The rewards duration

Used as gloabl variabel to set the rewards duration for all new reward tokens on InfraredVaults

function rewardsDuration() external view returns (uint256);

Returns

registerVault

Registers a new vault for a given asset

Infrared.sol must be admin over MINTER_ROLE on InfraredBGT to grant minter role to deployed vault

Note: emits: NewVault with the caller, asset address, and new vault address.

function registerVault(address _asset)
    external
    returns (IInfraredVault vault);

Parameters

Returns

addReward

Adds a new reward token to a specific staking vault

Only callable by governance when contract is initialized

Notes:

• error: ZeroAmount if _rewardsDuration is 0

• error: RewardTokenNotWhitelisted if _rewardsToken is not whitelisted

• error: NoRewardsVault if vault doesn't exist for _stakingToken

function addReward(
    address _stakingToken,
    address _rewardsToken,
    uint256 _rewardsDuration
) external;

Parameters

addIncentives

Adds reward incentives to a specific staking vault

Transfers reward tokens from caller to this contract, then notifies vault of new rewards

Notes:

• error: ZeroAmount if _amount is 0

• error: NoRewardsVault if vault doesn't exist for _stakingToken

• error: RewardTokenNotWhitelisted if reward token hasn't been configured for the vault

• access: Callable when contract is initialized

• security: Requires caller to have approved this contract to spend _rewardsToken

function addIncentives(
    address _stakingToken,
    address _rewardsToken,
    uint256 _amount
) external;

Parameters

updateWhiteListedRewardTokens

Updates the whitelist status of a reward token

function updateWhiteListedRewardTokens(address _token, bool _whitelisted)
    external;

Parameters

updateRewardsDuration

Sets the new duration for reward distributions in InfraredVaults

Only callable by governance

function updateRewardsDuration(uint256 _rewardsDuration) external;

Parameters

updateRewardsDurationForVault

Updates the rewards duration for a specific reward token on a specific vault

Only callable by governance

function updateRewardsDurationForVault(
    address _stakingToken,
    address _rewardsToken,
    uint256 _rewardsDuration
) external;

Parameters

toggleVault

Pauses staking functionality on a specific vault

Only callable by governance, will revert if vault doesn't exist

function toggleVault(address _asset) external;

Parameters

claimLostRewardsOnVault

Claims lost rewards on a specific vault

Only callable by governance, will revert if vault doesn't exist

function claimLostRewardsOnVault(address _asset) external;

Parameters

recoverERC20

Recovers ERC20 tokens sent accidentally to the contract

function recoverERC20(address _to, address _token, uint256 _amount) external;

Parameters

recoverERC20FromVault

Recover ERC20 tokens from a vault.

function recoverERC20FromVault(
    address _asset,
    address _to,
    address _token,
    uint256 _amount
) external;

Parameters

delegateBGT

Delegates BGT votes to _delegatee address.

function delegateBGT(address _delegatee) external;

Parameters

updateInfraredBERABribesWeight

Updates the weight for iBERA bribes

function updateInfraredBERABribesWeight(uint256 _weight) external;

Parameters

updateFee

Updates the fee rate charged on different harvest functions

Please harvest all assosiated rewards for a given type before updating

Fee rate in units of 1e6 or hundredths of 1 bip

function updateFee(ConfigTypes.FeeType _t, uint256 _fee) external;

Parameters

setRed

Sets the address of the RED contract

Infrared must be granted MINTER_ROLE on RED to set the address

function setRed(address _red) external;

Parameters

setIBGT

Sets the address of the iBGT contract

Infrared must be granted MINTER_ROLE on IBGT to set the address

function setIBGT(address _ibgt) external;

Parameters

updateRedMintRate

Updates the mint rate for RED

function updateRedMintRate(uint256 _redMintRate) external;

Parameters

claimProtocolFees

Claims accumulated protocol fees in contract

function claimProtocolFees(address _to, address _token, uint256 _amount)
    external;

Parameters

harvestBase

Claims all the BGT base and commission rewards minted to this contract for validators.

function harvestBase() external;

harvestOperatorRewards

Credits all accumulated rewards to the operator

function harvestOperatorRewards() external;

harvestVault

Claims all the BGT rewards for the vault associated with the given staking token.

function harvestVault(address _asset) external;

Parameters

harvestBribes

Claims all the bribes rewards in the contract forwarded from Berachain POL.

function harvestBribes(address[] memory _tokens) external;

Parameters

collectBribes

Collects bribes from bribe collector and distributes to wiBERA and iBGT Infrared vaults.

_token The payout token for the bribe collector.

_amount The amount of payout received from bribe collector.

function collectBribes(address _token, uint256 _amount) external;

harvestBoostRewards

Claims all the BGT staker rewards from boosting validators.

Sends rewards to iBGT vault.

function harvestBoostRewards() external;

addValidators

Adds validators to the set of InfraredValidators.

function addValidators(ValidatorTypes.Validator[] memory _validators)
    external;

Parameters

removeValidators

Removes validators from the set of InfraredValidators.

function removeValidators(bytes[] memory _pubkeys) external;

Parameters

replaceValidator

Replaces a validator in the set of InfraredValidators.

function replaceValidator(bytes calldata _current, bytes calldata _new)
    external;

Parameters

queueBoosts

Queue _amts of tokens to _validators for boosts.

function queueBoosts(bytes[] memory _pubkeys, uint128[] memory _amts)
    external;

Parameters

cancelBoosts

Removes _amts from previously queued boosts to _validators.

_pubkeys need not be in the current validator set in case just removed but need to cancel.

function cancelBoosts(bytes[] memory _pubkeys, uint128[] memory _amts)
    external;

Parameters

activateBoosts

Activates queued boosts for _pubkeys.

function activateBoosts(bytes[] memory _pubkeys) external;

Parameters

queueDropBoosts

Queues a drop boost of the validators removing an amount of BGT for sender.

Reverts if user does not have enough boosted balance to cover amount.

function queueDropBoosts(bytes[] calldata pubkeys, uint128[] calldata amounts)
    external;

Parameters

cancelDropBoosts

Cancels a queued drop boost of the validator removing an amount of BGT for sender.

function cancelDropBoosts(bytes[] calldata pubkeys, uint128[] calldata amounts)
    external;

Parameters

dropBoosts

Drops an amount of BGT from an existing boost of validators by user.

function dropBoosts(bytes[] calldata pubkeys) external;

Parameters

queueNewCuttingBoard

Queues a new cutting board on BeraChef for reward weight distribution for validator

function queueNewCuttingBoard(
    bytes calldata _pubkey,
    uint64 _startBlock,
    IBeraChef.Weight[] calldata _weights
) external;

Parameters

infraredValidators

Gets the set of infrared validator pubkeys.

function infraredValidators()
    external
    view
    returns (ValidatorTypes.Validator[] memory validators);

Returns

numInfraredValidators

Gets the number of infrared validators in validator set.

function numInfraredValidators() external view returns (uint256);

Returns

isInfraredValidator

Checks if a validator is an infrared validator.

function isInfraredValidator(bytes memory _pubkey)
    external
    view
    returns (bool);

Parameters

Returns

getBGTBalance

Gets the BGT balance for this contract

function getBGTBalance() external view returns (uint256 bgtBalance);

Returns

Events

NewVault

Emitted when a new vault is registered

event NewVault(address _sender, address indexed _asset, address indexed _vault);

Parameters

VaultRegistrationPauseStatus

Emitted when pause status for new vault registration has changed

event VaultRegistrationPauseStatus(bool pause);

Parameters

OperatorRewardsDistributed

Emitted when InfraredBGT tokens are supplied to distributor.

event OperatorRewardsDistributed(
    address indexed _ibera, address indexed _distributor, uint256 _amt
);

Parameters

InfraredBGTSupplied

Emitted when InfraredBGT tokens are supplied to a vault.

event InfraredBGTSupplied(
    address indexed _vault, uint256 _ibgtAmt, uint256 _iredAmt
);

Parameters

RewardSupplied

Emitted when rewards are supplied to a vault.

event RewardSupplied(
    address indexed _vault, address indexed _token, uint256 _amt
);

Parameters

BribeSupplied

Emitted when rewards are supplied to a vault.

event BribeSupplied(
    address indexed _recipient, address indexed _token, uint256 _amt
);

Parameters

Recovered

Emitted when tokens are recovered from the contract.

event Recovered(address _sender, address indexed _token, uint256 _amount);

Parameters

RewardTokenNotSupported

Emitted when a reward token is marked as unsupported.

event RewardTokenNotSupported(address _token);

Parameters

InfraredBGTUpdated

Emitted when the InfraredBGT token address is updated.

event InfraredBGTUpdated(address _sender, address _oldIbgt, address _newIbgt);

Parameters

InfraredBGTVaultUpdated

Emitted when the InfraredBGT vault address is updated.

event InfraredBGTVaultUpdated(
    address _sender, address _oldIbgtVault, address _newIbgtVault
);

Parameters

WhiteListedRewardTokensUpdated

Emitted when reward tokens are whitelisted or unwhitelisted.

event WhiteListedRewardTokensUpdated(
    address _sender,
    address indexed _token,
    bool _wasWhitelisted,
    bool _isWhitelisted
);

Parameters

RewardsDurationUpdated

Emitted when the rewards duration is updated

event RewardsDurationUpdated(
    address _sender, uint256 _oldDuration, uint256 _newDuration
);

Parameters

IredMintRateUpdated

Emitted when the IRED mint rate per unit InfraredBGT is updated.

event IredMintRateUpdated(
    address _sender, uint256 _oldMintRate, uint256 _newMintRate
);

Parameters

InfraredBERABribesWeightUpdated

Emitted when a weight is updated.

event InfraredBERABribesWeightUpdated(
    address _sender, uint256 _oldWeight, uint256 _newWeight
);

Parameters

FeeUpdated

Emitted when protocol fee rate is updated.

event FeeUpdated(
    address _sender,
    ConfigTypes.FeeType _feeType,
    uint256 _oldFeeRate,
    uint256 _newFeeRate
);

Parameters

ProtocolFeesClaimed

Emitted when protocol fees claimed.

event ProtocolFeesClaimed(
    address _sender, address _to, address _token, uint256 _amount
);

Parameters

ProtocolFees

Emitted when protocol fees are received.

event ProtocolFees(address indexed _token, uint256 _amt, uint256 _voterAmt);

Parameters

BaseHarvested

Emitted when base + commission rewards are harvested.

event BaseHarvested(address _sender, uint256 _bgtAmt);

Parameters

VaultHarvested

Emitted when a vault harvests its rewards.

event VaultHarvested(
    address _sender,
    address indexed _asset,
    address indexed _vault,
    uint256 _bgtAmt
);

Parameters

BribesCollected

Emitted when bribes are harvested then collected by collector.

event BribesCollected(
    address _sender,
    address _token,
    uint256 _amtWiberaVault,
    uint256 _amtIbgtVault
);

Parameters

ValidatorHarvested

Emitted when a validator harvests its rewards.

event ValidatorHarvested(
    address _sender,
    bytes indexed _validator,
    DataTypes.Token[] _rewards,
    uint256 _bgtAmt
);

Parameters

ValidatorsAdded

Emitted when validators are added.

event ValidatorsAdded(address _sender, ValidatorTypes.Validator[] _validators);

Parameters

ValidatorsRemoved

Emitted when validators are removed from validator set.

event ValidatorsRemoved(address _sender, bytes[] _pubkeys);

Parameters

ValidatorReplaced

Emitted when a validator is replaced with a new validator.

event ValidatorReplaced(address _sender, bytes _current, bytes _new);

Parameters

QueuedBoosts

Emitted when BGT tokens are queued for boosts to validators.

event QueuedBoosts(address _sender, bytes[] _pubkeys, uint128[] _amts);

Parameters

CancelledBoosts

Emitted when existing queued boosts to validators are cancelled.

event CancelledBoosts(address _sender, bytes[] _pubkeys, uint128[] _amts);

Parameters

ActivatedBoosts

Emitted when an existing boost to a validator is activated.

event ActivatedBoosts(address _sender, bytes[] _pubkeys);

Parameters

QueueDropBoosts

Emitted when an user queues a drop boost for a validator.

event QueueDropBoosts(
    address indexed user, bytes[] indexed pubkeys, uint128[] amounts
);

Parameters

CancelDropBoosts

Emitted when an user cancels a queued drop boost for a validator.

event CancelDropBoosts(
    address indexed user, bytes[] indexed pubkeys, uint128[] amounts
);

Parameters

DroppedBoosts

Emitted when sender removes an amount of BGT boost from a validator

event DroppedBoosts(address indexed _sender, bytes[] _pubkeys);

Parameters

Undelegated

Emitted when tokens are undelegated from a validator.

event Undelegated(address _sender, bytes _pubkey, uint256 _amt);

Parameters

Redelegated

Emitted when tokens are redelegated from one validator to another.

event Redelegated(address _sender, bytes _from, bytes _to, uint256 _amt);

Parameters

RedSet

Emitted when the RED token is set.

event RedSet(address _sender, address _red);

Parameters

UpdatedRedMintRate

event UpdatedRedMintRate(
    uint256 oldMintRate, uint256 newMintRate, address sender
);

Parameters

IBGTSet

Emitted when the iBGT token is set.

event IBGTSet(address _sender, address _ibgt);

Parameters

IInfraredBERA

Git Source

Inherits: IERC20, IAccessControl

Functions

infrared

Address of the Infrared operator contract

function infrared() external view returns (address);

depositor

Address of the depositor that interacts with chain deposit precompile

function depositor() external view returns (address);

withdrawor

Address of the withdrawor that interacts with chain withdraw precompile

function withdrawor() external view returns (address);

receivor

Address of the fee receivor contract that receives tx priority fees + MEV on EL

function receivor() external view returns (address);

deposits

Deposits of BERA backing InfraredBERA intended for use in CL by validators

function deposits() external view returns (uint256);

Returns

stakes

Returns the amount of BERA staked in validator with given pubkey

function stakes(bytes calldata pubkey) external view returns (uint256);

Returns

staked

Returns whether initial deposit has been staked to validator with given pubkey

function staked(bytes calldata pubkey) external view returns (bool);

Returns

hasExited

Checks if a validator has been force exited from the Consensus Layer

exited validators can no longer be deposited in.

function hasExited(bytes calldata pubkey) external view returns (bool);

Parameters

Returns

signatures

Returns the deposit signature to use for given pubkey

function signatures(bytes calldata pubkey)
    external
    view
    returns (bytes memory);

Returns

feeDivisorShareholders

Fee taken by the shareholders on yield from EL coinbase priority fees + MEV, represented as an integer denominator (1/x)%

additional fees include POL base rewards, POL comission, POL bribes

function feeDivisorShareholders() external view returns (uint16);

Returns

pending

Pending deposits yet to be forwarded to CL

function pending() external view returns (uint256);

Returns

confirmed

Confirmed deposits sent to CL

function confirmed() external view returns (uint256);

Returns

keeper

Returns whether given account is an InfraredBERA keeper

function keeper(address account) external view returns (bool);

Returns

governor

Returns whether given account is an InfraredBERA governor

function governor(address account) external view returns (bool);

Returns

validator

Returns whether given pubkey is in Infrared validator set

function validator(bytes calldata pubkey) external view returns (bool);

Returns

previewMint

Previews the amount of InfraredBERA shares that would be minted for a given BERA amount

function previewMint(uint256 beraAmount)
    external
    view
    returns (uint256 shares, uint256 fee);

Parameters

Returns

previewBurn

Previews the amount of BERA that would be received for burning InfraredBERA shares

function previewBurn(uint256 shares)
    external
    view
    returns (uint256 beraAmount, uint256 fee);

Parameters

Returns

initialize

Initializes InfraredBERA to allow for future mints and burns

Must be called before InfraredBERA can offer deposits and withdraws

function initialize(
    address _gov,
    address _keeper,
    address _infrared,
    address _depositor,
    address _withdrawor,
    address _receivor
) external payable;

compound

Compounds accumulated EL yield in fee receivor into deposits

Called internally at bof whenever InfraredBERA minted or burned

Only sweeps if amount transferred from fee receivor would exceed min deposit thresholds

function compound() external;

sweep

Sweeps received funds in msg.value as yield into deposits

Fee receivor must call this function in its sweep function for autocompounding

function sweep() external payable;

collect

Collects yield from fee receivor and mints ibera shares to Infrared

Only Infrared can call this function

function collect() external returns (uint256 sharesMinted);

Returns

mint

Mints ibera shares to receiver for bera paid in by sender

function mint(address receiver)
    external
    payable
    returns (uint256 nonce, uint256 shares);

Parameters

Returns

burn

Burns ibera shares from sender for bera to ultimately be transferred to receiver on subsequent call to claim

Sender must pay withdraw precompile fee upfront

function burn(address receiver, uint256 shares)
    external
    payable
    returns (uint256 nonce, uint256 amount);

Parameters

Returns

register

Registers update to BERA staked in validator with given pubkey at CL

Reverts if not called by depositor or withdrawor

function register(bytes calldata pubkey, int256 delta) external;

Parameters

setFeeDivisorShareholders

Sets the fee shareholders taken on yield from EL coinbase priority fees + MEV

function setFeeDivisorShareholders(uint16 to) external;

Parameters

setDepositSignature

Sets the deposit signature to be used when depositing to pubkey

function setDepositSignature(bytes calldata pubkey, bytes calldata signature)
    external;

Parameters

withdrawalsEnabled

Flag to show whether withdrawals are currently enabled

function withdrawalsEnabled() external view returns (bool);

Returns

Events

Mint

event Mint(
    address indexed receiver,
    uint256 nonce,
    uint256 amount,
    uint256 shares,
    uint256 fee
);

Burn

event Burn(
    address indexed receiver,
    uint256 nonce,
    uint256 amount,
    uint256 shares,
    uint256 fee
);

Sweep

event Sweep(uint256 amount);

Register

event Register(bytes pubkey, int256 delta, uint256 stake);

SetFeeShareholders

event SetFeeShareholders(uint16 from, uint16 to);

SetDepositSignature

event SetDepositSignature(bytes pubkey, bytes from, bytes to);

WithdrawalFlagSet

event WithdrawalFlagSet(bool flag);

IInfraredBERAClaimor

Git Source

Functions

claims

Outstanding BERA claims for a receiver

function claims(address receiver) external view returns (uint256);

Parameters

queue

Queues a new BERA claim for a receiver

Only callable by the InfraredBERAWithdrawor contract

function queue(address receiver) external payable;

Parameters

sweep

Sweeps oustanding BERA claims for a receiver to their address

function sweep(address receiver) external;

Parameters

Events

Queue

event Queue(address indexed receiver, uint256 amount, uint256 claim);

Sweep

event Sweep(address indexed receiver, uint256 amount);

IInfraredBERADepositor

Git Source

Functions

InfraredBERA

The address of InfraredBERA

function InfraredBERA() external view returns (address);

slips

Outstanding slips for deposits on previously minted ibera

function slips(uint256 nonce)
    external
    view
    returns (uint96 timestamp, uint256 fee, uint256 amount);

Parameters

Returns

fees

Amount of BERA internally set aside for deposit contract request fees

function fees() external view returns (uint256);

reserves

Amount of BERA internally set aside to execute deposit contract requests

function reserves() external view returns (uint256);

nonceSlip

The next nonce to issue deposit slip for

function nonceSlip() external view returns (uint256);

nonceSubmit

The next nonce to submit deposit slip for

function nonceSubmit() external view returns (uint256);

queue

Queues a deposit from InfraredBERA for chain deposit precompile escrowing msg.value in contract

function queue(uint256 amount) external payable returns (uint256 nonce);

Parameters

Returns

execute

Executes a deposit to deposit precompile using escrowed funds

function execute(bytes calldata pubkey, uint256 amount) external;

Parameters

Events

Queue

event Queue(uint256 nonce, uint256 amount);

Execute

event Execute(bytes pubkey, uint256 start, uint256 end, uint256 amount);

IInfraredBERAFeeReceivor

Git Source

Functions

InfraredBERA

The address of InfraredBERA

function InfraredBERA() external view returns (address);

shareholderFees

Accumulated protocol fees in contract to be claimed by governor

function shareholderFees() external view returns (uint256);

distribution

Amount of BERA swept to InfraredBERA and fees taken for protool on next call to sweep

function distribution() external view returns (uint256 amount, uint256 fees);

Returns

sweep

Sweeps accumulated coinbase priority fees + MEV to InfraredBERA to autocompound principal

function sweep() external returns (uint256 amount, uint256 fees);

collect

Collects accumulated shareholder fees

Reverts if msg.sender is not iBERA contract

function collect() external returns (uint256 sharesMinted);

Returns

Events

Sweep

event Sweep(address indexed receiver, uint256 amount, uint256 fees);

Collect

event Collect(address indexed receiver, uint256 amount, uint256 sharesMinted);

IInfraredBERAWithdrawor

Git Source

Functions

InfraredBERA

The address of InfraredBERA

function InfraredBERA() external view returns (address);

sweep

Sweeps forced withdrawals to InfraredBERA to re-stake principal

function sweep(bytes calldata pubkey) external;

requests

Outstanding requests for claims on previously burnt ibera

function requests(uint256 nonce)
    external
    view
    returns (
        address receiver,
        uint96 timestamp,
        uint256 fee,
        uint256 amountSubmit,
        uint256 amountProcess
    );

Parameters

Returns

fees

Amount of BERA internally set aside for withdraw precompile request fees

function fees() external view returns (uint256);

reserves

Amount of BERA internally set aside to process withdraw compile requests from funds received on successful requests

function reserves() external view returns (uint256);

rebalancing

Amount of BERA internally rebalancing amongst Infrared validators

function rebalancing() external view returns (uint256);

nonceRequest

The next nonce to issue withdraw request for

function nonceRequest() external view returns (uint256);

nonceSubmit

The next nonce to submit withdraw request for

function nonceSubmit() external view returns (uint256);

nonceProcess

The next nonce in queue to process claims for

function nonceProcess() external view returns (uint256);

queue

Queues a withdraw from InfraredBERA for chain withdraw precompile escrowing minimum fees for request to withdraw precompile

function queue(address receiver, uint256 amount)
    external
    payable
    returns (uint256 nonce);

Parameters

Returns

execute

Executes a withdraw request to withdraw precompile

Payable in case excess bera required to satisfy withdraw precompile fee

function execute(bytes calldata pubkey, uint256 amount) external payable;

Parameters

process

Processes the funds received from withdraw precompile to next-to-process request receiver

Reverts if balance has not increased by full amount of request for next-to-process request nonce

function process() external;

Events

Queue

event Queue(address indexed receiver, uint256 nonce, uint256 amount);

Execute

event Execute(bytes pubkey, uint256 start, uint256 end, uint256 amount);

Process

event Process(address indexed receiver, uint256 nonce, uint256 amount);

Sweep

event Sweep(address indexed receiver, uint256 amount);

IInfraredBGT

Git Source

Inherits: IERC20Mintable, IAccessControl

Functions

bgt

The address of the BGT non-transferrable ERC20 token

function bgt() external view returns (address);

IInfraredDistributor

Git Source

Interface for distributing validator commissions and rewards

Handles reward distribution snapshots and claiming logic for validators

Functions

token

Token used for reward distributions

function token() external view returns (ERC20);

Returns

amountsCumulative

Tracks reward amount accumulation per validator

function amountsCumulative() external view returns (uint256);

Returns

getSnapshot

Get validator's reward snapshots

Returns (0,0) if validator doesn't exist

function getSnapshot(bytes calldata pubkey)
    external
    view
    returns (uint256 amountCumulativeLast, uint256 amountCumulativeFinal);

Parameters

Returns

getValidator

Get validator's registered claim address

function getValidator(bytes calldata pubkey) external view returns (address);

Parameters

Returns

add

Register new validator for rewards

Only callable by Infrared contract

Notes:

• access-control: Requires INFRARED_ROLE

• error: ValidatorAlreadyExists if validator already registered

function add(bytes calldata pubkey, address validator) external;

Parameters

remove

Removes validator from reward-eligible set

Only callable by Infrared contract

Note: access-control: Requires INFRARED_ROLE

function remove(bytes calldata pubkey) external;

Parameters

purge

Purges validator from registry completely

Only possible after all rewards are claimed

Note: error: ClaimableRewardsExist if unclaimed rewards remain

function purge(bytes calldata pubkey) external;

Parameters

notifyRewardAmount

Distributes new commission rewards to validator set

Notes:

• error: ZeroAmount if amount is 0

• error: InvalidValidator if no validators exist

function notifyRewardAmount(uint256 amount) external;

Parameters

claim

Claims outstanding commission rewards

Notes:

• error: InvalidValidator if caller not authorized

• error: ZeroAmount if no rewards to claim

function claim(bytes calldata pubkey, address recipient) external;

Parameters

Events

Added

Emitted when validator is added to commission-eligible set

event Added(bytes pubkey, address operator, uint256 amountCumulative);

Parameters

Removed

Emitted when validator is removed from commission-eligible set

event Removed(bytes pubkey, address operator, uint256 amountCumulative);

Parameters

Purged

Emitted when validator is fully purged from registry

event Purged(bytes pubkey, address validator);

Parameters

Notified

Emitted when new commission rewards are added

event Notified(uint256 amount, uint256 num);

Parameters

Claimed

Emitted when validator claims their commission

event Claimed(
    bytes pubkey, address validator, address recipient, uint256 amount
);

Parameters

Structs

Snapshot

Reward accumulation checkpoints for validators

Used to calculate claimable rewards between snapshots

struct Snapshot {
    uint256 amountCumulativeLast;
    uint256 amountCumulativeFinal;
}

IInfraredUpgradeable

Git Source

Inherits: IAccessControl

Functions

KEEPER_ROLE

Access control for keeper role

function KEEPER_ROLE() external view returns (bytes32);

GOVERNANCE_ROLE

Access control for governance role

function GOVERNANCE_ROLE() external view returns (bytes32);

infrared

Infrared coordinator contract

function infrared() external view returns (address);

IInfraredVault

Git Source

Inherits: IMultiRewards

Functions

getAllRewardTokens

Returns all reward tokens

function getAllRewardTokens() external view returns (address[] memory);

Returns

getAllRewardsForUser

Returns all rewards for a user

Only up to date since the lastUpdateTime

function getAllRewardsForUser(address _user)
    external
    view
    returns (UserReward[] memory);

Parameters

Returns

infrared

Returns the Infrared protocol coordinator

function infrared() external view returns (address);

Returns

rewardsVault

Returns the associated Berachain rewards vault

function rewardsVault() external view returns (IBerachainRewardsVault);

Returns

updateRewardsDuration

Updates reward duration for a specific reward token

Only callable by Infrared contract

Note: access-control: Requires INFRARED_ROLE

function updateRewardsDuration(address _rewardsToken, uint256 _rewardsDuration)
    external;

Parameters

togglePause

Toggles pause state of the vault

Affects all vault operations when paused

Note: access-control: Requires INFRARED_ROLE

function togglePause() external;

addReward

Adds a new reward token to the vault

Cannot exceed maximum number of reward tokens

Note: access-control: Requires INFRARED_ROLE

function addReward(address _rewardsToken, uint256 _rewardsDuration) external;

Parameters

notifyRewardAmount

Notifies the vault of newly added rewards

Updates internal reward rate calculations

function notifyRewardAmount(address _rewardToken, uint256 _reward) external;

Parameters

recoverERC20

Recovers accidentally sent tokens

Cannot recover staking token or active reward tokens

function recoverERC20(address _to, address _token, uint256 _amount) external;

Parameters

Structs

UserReward

A struct to hold a user's reward information

struct UserReward {
    address token;
    uint256 amount;
}

Properties

IMultiRewards

Git Source

Functions

totalSupply

Returns the total amount of staked tokens in the contract

function totalSupply() external view returns (uint256);

Returns