analyze_results.json

{
  "WBERA.name": {
    "type": "public pure override",
    "function_name": "name() returns (string memory)",
    "analysis_result": "This function overrides the `name()` function from the inherited `WETH` contract. It is a `public` and `pure` function, meaning it does not read from or write to the contract's state. Its purpose is to return the official name of the token. It simply returns the constant string \"Wrapped Bera\". It does not use any variables or interact with storage. It does not call any other functions."
  },
  "WBERA.symbol": {
    "type": "public pure override",
    "function_name": "symbol() returns (string memory)",
    "analysis_result": "This function overrides the `symbol()` function from the inherited `WETH` contract. It is a `public` and `pure` function, meaning it does not read from or write to the contract's state. Its purpose is to return the ticker symbol of the token. It simply returns the constant string \"WBERA\". It does not use any variables or interact with storage. It does not call any other functions."
  },
  "POLDeployer.constructor": {
    "type": "constructor",
    "function_name": "constructor(address bgt, address governance, uint256 beraChefSalt, uint256 blockRewardControllerSalt, uint256 distributorSalt, uint256 rewardVaultFactorySalt)",
    "analysis_result": "This is the constructor function of the POLDeployer contract. Its purpose is to deploy and initialize the core Proof of Liquidity (PoL) related contracts using the CREATE2 opcode for predictable addresses. It takes several arguments:\n- `bgt`: The address of the BGT token contract.\n- `governance`: The address of the governance contract, likely the owner or controller of the deployed contracts.\n- `beraChefSalt`: A salt value used for deploying the BeraChef proxy.\n- `blockRewardControllerSalt`: A salt value used for deploying the BlockRewardController proxy.\n- `distributorSalt`: A salt value used for deploying the Distributor proxy.\n- `rewardVaultFactorySalt`: A salt value used for deploying the RewardVaultFactory proxy.\nThe function performs the following steps:\n1.  Deploys the implementation contract for `BeraChef` using `deployWithCreate2` with a salt of 0 (effectively standard CREATE).\n2.  Deploys the proxy contract for `BeraChef` using `deployProxyWithCreate2`, passing the deployed implementation address and the provided `beraChefSalt`. The resulting proxy address is stored in the immutable state variable `beraChef`.\n3.  Deploys the implementation contract for `BlockRewardController` using `deployWithCreate2` (salt 0).\n4.  Deploys the proxy contract for `BlockRewardController` using `deployProxyWithCreate2` with the implementation address and `blockRewardControllerSalt`. The address is stored in the immutable `blockRewardController` variable.\n5.  Deploys the implementation contract for `Distributor` using `deployWithCreate2` (salt 0).\n6.  Deploys the proxy contract for `Distributor` using `deployProxyWithCreate2` with the implementation address and `distributorSalt`. The address is stored in the immutable `distributor` variable.\n7.  Deploys the implementation contract for `RewardVault` using `deployWithCreate2` (salt 0). This is needed by the factory but not stored directly in a state variable of this contract.\n8.  Deploys the implementation contract for `RewardVaultFactory` using `deployWithCreate2` (salt 0).\n9.  Deploys the proxy contract for `RewardVaultFactory` using `deployProxyWithCreate2` with the implementation address and `rewardVaultFactorySalt`. The address is stored in the immutable `rewardVaultFactory` variable.\n10. Initializes the deployed `beraChef` proxy by calling its `initialize` function with the address of the deployed `distributor`, the address of the deployed `rewardVaultFactory`, the `governance` address, the `BEACON_DEPOSIT` constant, and the `maxNumWeightsPerRewardAllocation` constant.\n11. Initializes the deployed `blockRewardController` proxy by calling its `initialize` function with the `bgt` address, the address of the deployed `distributor`, the `BEACON_DEPOSIT` constant, and the `governance` address.\n12. Initializes the deployed `distributor` proxy by calling its `initialize` function with the address of the deployed `beraChef`, the `bgt` address, the address of the deployed `blockRewardController`, the `governance` address, the `ZERO_VALIDATOR_PUBKEY_G_INDEX` constant, and the `PROPOSER_INDEX_G_INDEX` constant.\n13. Initializes the deployed `rewardVaultFactory` proxy by calling its `initialize` function with the `bgt` address, the address of the deployed `distributor`, the `BEACON_DEPOSIT` constant, the `governance` address, and the address of the deployed `RewardVault` implementation.\n\nVariables Used:\n- Reads from arguments: `bgt`, `governance`, `beraChefSalt`, `blockRewardControllerSalt`, `distributorSalt`, `rewardVaultFactorySalt`.\n- Reads constants: `maxNumWeightsPerRewardAllocation`, `ZERO_VALIDATOR_PUBKEY_G_INDEX`, `PROPOSER_INDEX_G_INDEX`, `BEACON_DEPOSIT`.\n- Writes to storage (immutable): `beraChef`, `blockRewardController`, `distributor`, `rewardVaultFactory`.\n\nFunctions Called:\n- `deployWithCreate2(0, ...)`: Inherited, used multiple times to deploy implementation contracts.\n- `deployProxyWithCreate2(..., salt)`: Inherited, used multiple times to deploy proxy contracts.\n- `beraChef.initialize(...)`: Called on the deployed BeraChef proxy.\n- `blockRewardController.initialize(...)`: Called on the deployed BlockRewardController proxy.\n- `distributor.initialize(...)`: Called on the deployed Distributor proxy.\n- `rewardVaultFactory.initialize(...)`: Called on the deployed RewardVaultFactory proxy."
  },
  "BeaconRootsHelper.setZeroValidatorPubkeyGIndex": {
    "type": "public virtual",
    "function_name": "setZeroValidatorPubkeyGIndex(uint64 _zeroValidatorPubkeyGIndex)",
    "analysis_result": "This function allows setting the `zeroValidatorPubkeyGIndex` storage variable, which represents the Generalized Index of the pubkey for the first validator (validator index 0) in the beacon state's validator registry. The input parameter `_zeroValidatorPubkeyGIndex` is assigned directly to the storage variable. It emits the `ZeroValidatorPubkeyGIndexChanged` event with the new value. This function is marked as `virtual`, allowing derived contracts to override its behavior. The `@dev` comment indicates that this function should be permissioned to restrict who can call it, although the abstract contract itself does not implement access control."
  },
  "BeaconRootsHelper.setProposerIndexGIndex": {
    "type": "public virtual",
    "function_name": "setProposerIndexGIndex(uint64 _proposerIndexGIndex)",
    "analysis_result": "This function allows setting the `proposerIndexGIndex` storage variable, which represents the Generalized Index of the proposer index field within the beacon block. The input parameter `_proposerIndexGIndex` is assigned directly to the storage variable. It emits the `ProposerIndexGIndexChanged` event with the new value. This function is marked as `virtual`, allowing derived contracts to override its behavior. The `@dev` comment indicates that this function should be permissioned to restrict who can call it, although the abstract contract itself does not implement access control."
  },
  "BeaconRootsHelper.isTimestampActionable": {
    "type": "external view",
    "function_name": "isTimestampActionable(uint64 timestamp)",
    "analysis_result": "This function checks if a given `timestamp` is currently present in the EIP-4788 Beacon Roots history buffer AND has not yet been marked as processed within this contract's local buffer (`_processedTimestampsBuffer`). It first calls the `isParentBlockRootAt()` function via the `BeaconRoots` library extension on the input `timestamp`. If this returns false, the timestamp is not in the EIP-4788 buffer, and the function returns `false`. If the timestamp is in the EIP-4788 buffer, it calculates the index in `_processedTimestampsBuffer` using `timestamp % HISTORY_BUFFER_LENGTH`. It then checks if the timestamp stored at this index in `_processedTimestampsBuffer` is *not* equal to the input `timestamp`. If they are different, it means the timestamp hasn't been processed locally, and the function returns `true` (actionable). If they are equal, it means it has been processed locally, and the function returns `false`."
  },
  "BeaconRootsHelper._processTimestampInBuffer": {
    "type": "internal",
    "function_name": "_processTimestampInBuffer(uint64 timestamp)",
    "analysis_result": "This internal function attempts to process a given `timestamp`, marking it as processed in the contract's local buffer (`_processedTimestampsBuffer`) and returning the corresponding parent beacon block root from the EIP-4788 buffer. It first calls `getParentBlockRootAt()` using the `BeaconRoots` library extension on the input `timestamp`. This call will revert if the timestamp is not found in the EIP-4788 buffer. It then calculates the index in `_processedTimestampsBuffer` using `timestamp % HISTORY_BUFFER_LENGTH`. It checks if the timestamp currently stored at this index is equal to the input `timestamp`. If they are equal, it means the timestamp has already been processed locally, and the function reverts with `TimestampAlreadyProcessed`. If the timestamp is found in the EIP-4788 buffer and not yet processed locally, the function updates `_processedTimestampsBuffer[timestampIndex]` to the input `timestamp`, effectively marking it as processed. Finally, it emits the `TimestampProcessed` event and returns the `parentBeaconBlockRoot` obtained from the EIP-4788 buffer."
  },
  "BeaconRootsHelper._verifyProposerIndexInBeaconBlock": {
    "type": "internal view",
    "function_name": "_verifyProposerIndexInBeaconBlock(bytes32 beaconBlockRoot, bytes32[] calldata proposerIndexProof, uint64 proposerIndex)",
    "analysis_result": "This internal view function verifies an SSZ proof that a specific `proposerIndex` is correctly included within the beacon block identified by `beaconBlockRoot`. It first calculates the SSZ Hash Tree Root of the `proposerIndex` using the `SSZ.uint64HashTreeRoot` library function. It then calls the `SSZ.verifyProof` library function, passing the provided `proposerIndexProof`, the `beaconBlockRoot`, the calculated `proposerIndexRoot`, and the stored `proposerIndexGIndex`. If the `SSZ.verifyProof` call returns `false`, indicating the proof is invalid, the function reverts with `InvalidProof`."
  },
  "BeaconRootsHelper._verifyValidatorPubkeyInBeaconBlock": {
    "type": "internal view",
    "function_name": "_verifyValidatorPubkeyInBeaconBlock(bytes32 beaconBlockRoot, bytes32[] calldata validatorPubkeyProof, bytes calldata validatorPubkey, uint64 validatorIndex)",
    "analysis_result": "This internal view function verifies an SSZ proof that a specific `validatorPubkey` is present at the correct position (`validatorIndex`) within the validator registry of the beacon state, rooted by `beaconBlockRoot`. It first checks if the provided `validatorIndex` is greater than or equal to the constant `VALIDATOR_REGISTRY_LIMIT` (1 << 40). If it is, the index is out of a valid range, and the function reverts with `IndexOutOfRange`. Otherwise, it calculates the SSZ Hash Tree Root of the `validatorPubkey` using the `SSZ.validatorPubkeyHashTreeRoot` library function. It then calculates the expected Generalized Index for this specific validator's pubkey by adding `VALIDATOR_PUBKEY_OFFSET` multiplied by the `validatorIndex` to the stored `zeroValidatorPubkeyGIndex`. Finally, it calls the `SSZ.verifyProof` library function with the provided `validatorPubkeyProof`, the `beaconBlockRoot`, the calculated `validatorPubkeyRoot`, and the derived Generalized Index. If `SSZ.verifyProof` returns `false`, the proof is invalid, and the function reverts with `InvalidProof`."
  },
  "FeeCollector.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor for the `FeeCollector` contract. It is marked with `/// @custom:oz-upgrades-unsafe-allow constructor` and calls `_disableInitializers()`. In upgradeable contracts using the UUPS pattern via OpenZeppelin, the constructor is typically used to disable the initializers for the base contract (the implementation contract) to prevent them from being called directly, which could lead to state inconsistencies when used via a proxy. The actual initialization logic is moved to an `initialize` function."
  },
  "FeeCollector.initialize": {
    "type": "external",
    "function_name": "initialize(address governance, address _payoutToken, address _rewardReceiver, uint256 _payoutAmount)",
    "analysis_result": "This is the initializer function for the upgradeable contract, replacing a standard constructor for setting initial state. It is marked `external` and uses the `initializer` modifier from OpenZeppelin's upgradeable contracts, which ensures it can only be called once. It requires four parameters: `governance` (the address granted the `DEFAULT_ADMIN_ROLE`), `_payoutToken` (the address of the token used for payouts), `_rewardReceiver` (the address, expected to be the `BGTStaker`, that receives payout tokens), and `_payoutAmount` (the fixed amount of `_payoutToken` to transfer upon each successful `claimFees` call).\n\n**Logic:**\n1.  It calls `__AccessControl_init()`, `__Pausable_init()`, and `__UUPSUpgradeable_init()` to initialize the base OpenZeppelin upgradeable contracts.\n2.  It checks if `governance`, `_payoutToken`, or `_rewardReceiver` are the zero address. If any are zero, it reverts with the `ZeroAddress.selector` error.\n3.  It checks if `_payoutAmount` is zero. If it is, it reverts with the `PayoutAmountIsZero.selector` error.\n4.  It grants the `DEFAULT_ADMIN_ROLE` to the `governance` address using `_grantRole`.\n5.  It sets the admin role for the `PAUSER_ROLE` to the `MANAGER_ROLE` using `_setRoleAdmin`. This means only addresses with the `MANAGER_ROLE` can grant or revoke the `PAUSER_ROLE`.\n6.  It sets the storage variable `payoutToken` to `_payoutToken`.\n7.  It sets the storage variable `payoutAmount` to `_payoutAmount`.\n8.  It sets the storage variable `rewardReceiver` to `_rewardReceiver`.\n9.  It emits the `PayoutAmountSet` event with the initial old amount (0) and the new amount (`_payoutAmount`).\n\n**Storage Variables Modified:** `payoutToken`, `payoutAmount`, `rewardReceiver`, and internal state variables managed by `__AccessControl_init`, `__Pausable_init`, and `__UUPSUpgradeable_init`.\n\n**Events Emitted:** `PayoutAmountSet`."
  },
  "FeeCollector._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This internal function is an override required by `UUPSUpgradeable`. It is called internally by the `_upgradeTo` function (or similar functions provided by the proxy pattern) before an upgrade is performed. Its purpose is to implement access control or other checks to determine if the calling context is authorized to initiate an upgrade.\n\n**Logic:**\n1.  It applies the `onlyRole(DEFAULT_ADMIN_ROLE)` modifier.\n\n**Storage Variables Modified:** None directly.\n\n**Modifiers Used:** `onlyRole(DEFAULT_ADMIN_ROLE)` (ensures only the address with the default admin role, typically the governance address set during initialization, can trigger an upgrade)."
  },
  "FeeCollector.queuePayoutAmountChange": {
    "type": "external",
    "function_name": "queuePayoutAmountChange(uint256 _newPayoutAmount)",
    "analysis_result": "This function allows an authorized role to queue a change to the `payoutAmount`. The change is not applied immediately but stored in `queuedPayoutAmount`. The actual change happens later when `claimFees` is called and `queuedPayoutAmount` is non-zero.\n\n**Logic:**\n1.  It applies the `onlyRole(DEFAULT_ADMIN_ROLE)` modifier, restricting access to the default admin.\n2.  It checks if the `_newPayoutAmount` is zero. If it is, it reverts with the `PayoutAmountIsZero.selector` error.\n3.  It emits the `QueuedPayoutAmount` event, indicating the old `payoutAmount` and the new `_newPayoutAmount` being queued.\n4.  It updates the storage variable `queuedPayoutAmount` with the provided `_newPayoutAmount`.\n\n**Storage Variables Modified:** `queuedPayoutAmount`.\n\n**Events Emitted:** `QueuedPayoutAmount`.\n\n**Errors Reverted:** `PayoutAmountIsZero.selector`."
  },
  "FeeCollector.claimFees": {
    "type": "external",
    "function_name": "claimFees(address _recipient, address[] calldata _feeTokens)",
    "analysis_result": "This function is the primary mechanism for claiming collected fees and initiating a payout to the reward receiver. It is marked `external` and uses the `whenNotPaused` modifier, meaning it cannot be called when the contract is paused. It requires two parameters: `_recipient` (the address to which the collected fee tokens will be sent) and `_feeTokens` (an array of addresses of the fee tokens to collect).\n\n**Logic:**\n1.  It applies the `whenNotPaused` modifier.\n2.  It transfers a fixed amount (`payoutAmount`) of the `payoutToken` from the caller (`msg.sender`) to the `rewardReceiver` (expected to be the `BGTStaker` contract) using `IERC20(payoutToken).safeTransferFrom`. This requires `msg.sender` to have approved this contract to spend at least `payoutAmount` of the `payoutToken` on their behalf.\n3.  It calls `notifyRewardAmount(payoutAmount)` on the `rewardReceiver` contract (casting it as a `BGTStaker`). This notifies the reward receiver (staker) that a payout has occurred and updates their reward calculation.\n4.  It iterates through the `_feeTokens` array:\n    a.  For each `feeToken`, it gets the current balance of that token held by the `FeeCollector` contract using `IERC20(feeToken).balanceOf(address(this))`. This represents the collected fees of that token.\n    b.  It transfers the entire balance of that `feeToken` from the `FeeCollector` contract to the `_recipient` using `IERC20(feeToken).safeTransfer`.\n    c.  It emits the `FeesClaimed` event for each individual fee token transferred, including the caller, recipient, token address, and amount.\n5.  After the loop, it emits a general `FeesClaimed` event indicating the caller and recipient for the overall fee claim operation.\n6.  Finally, it checks if `queuedPayoutAmount` is non-zero. If it is, it calls the internal function `_setPayoutAmount()` to apply the queued change.\n\n**Storage Variables Read:** `payoutToken`, `payoutAmount`, `rewardReceiver`, `queuedPayoutAmount`.\n\n**Storage Variables Modified:** `payoutAmount`, `queuedPayoutAmount` (if `queuedPayoutAmount` was non-zero).\n\n**External Calls:**\n*   `IERC20(payoutToken).safeTransferFrom(msg.sender, rewardReceiver, payoutAmount)`\n*   `BGTStaker(rewardReceiver).notifyRewardAmount(payoutAmount)`\n*   `IERC20(feeToken).balanceOf(address(this))` (within the loop)\n*   `IERC20(feeToken).safeTransfer(_recipient, feeTokenAmountToTransfer)` (within the loop)\n\n**Events Emitted:** `FeesClaimed` (multiple times), potentially `PayoutAmountSet` if `_setPayoutAmount` is called.\n\n**Modifiers Used:** `whenNotPaused`."
  },
  "FeeCollector.donate": {
    "type": "external",
    "function_name": "donate(uint256 amount)",
    "analysis_result": "This function allows anyone (when not paused) to donate `payoutToken` directly to the `rewardReceiver`. It is marked `external` and uses the `whenNotPaused` modifier. It takes one parameter: `amount`, the amount of `payoutToken` to donate.\n\n**Logic:**\n1.  It applies the `whenNotPaused` modifier.\n2.  It checks if the `amount` is less than the current `payoutAmount`. The comment suggests it should be at least `payoutAmount` to notify the receiver, but the check only ensures it's not less. If `amount` is less than `payoutAmount`, it reverts with the `DonateAmountLessThanPayoutAmount.selector` error.\n3.  It transfers the specified `amount` of the `payoutToken` from the caller (`msg.sender`) directly to the `rewardReceiver` using `IERC20(payoutToken).safeTransferFrom`. This requires `msg.sender` to have approved this contract to spend at least `amount` of the `payoutToken`.\n4.  It calls `notifyRewardAmount(amount)` on the `rewardReceiver` contract (casting it as a `BGTStaker`), notifying the receiver of the donation and updating their reward calculation.\n5.  It emits the `PayoutDonated` event, indicating the caller and the donated `amount`.\n\n**Storage Variables Read:** `payoutToken`, `payoutAmount`, `rewardReceiver`.\n\n**Storage Variables Modified:** None directly.\n\n**External Calls:**\n*   `IERC20(payoutToken).safeTransferFrom(msg.sender, rewardReceiver, amount)`\n*   `BGTStaker(rewardReceiver).notifyRewardAmount(amount)`\n\n**Events Emitted:** `PayoutDonated`.\n\n**Modifiers Used:** `whenNotPaused`.\n\n**Errors Reverted:** `DonateAmountLessThanPayoutAmount.selector`."
  },
  "FeeCollector.pause": {
    "type": "external",
    "function_name": "pause()",
    "analysis_result": "This function allows an authorized role to pause the contract, preventing calls to functions marked with `whenNotPaused`. It is marked `external`.\n\n**Logic:**\n1.  It applies the `onlyRole(PAUSER_ROLE)` modifier, restricting access to addresses holding the `PAUSER_ROLE`.\n2.  It calls the internal `_pause()` function, which is inherited from `PausableUpgradeable` and handles setting the paused state and emitting the `Paused` event.\n\n**Storage Variables Modified:** Internal state variable managed by `_pause()`.\n\n**Events Emitted:** `Paused` (by `_pause()`)."
  },
  "FeeCollector.unpause": {
    "type": "external",
    "function_name": "unpause()",
    "analysis_result": "This function allows an authorized role to unpause the contract, re-enabling calls to functions marked with `whenNotPaused`. It is marked `external`.\n\n**Logic:**\n1.  It applies the `onlyRole(MANAGER_ROLE)` modifier, restricting access to addresses holding the `MANAGER_ROLE`. Recall that the `MANAGER_ROLE` is set as the admin for the `PAUSER_ROLE` in `initialize`, allowing managers to manage pausers, but here the manager itself is given the ability to unpause.\n2.  It calls the internal `_unpause()` function, which is inherited from `PausableUpgradeable` and handles unsetting the paused state and emitting the `Unpaused` event.\n\n**Storage Variables Modified:** Internal state variable managed by `_unpause()`.\n\n**Events Emitted:** `Unpaused` (by `_unpause()`)."
  },
  "FeeCollector._setPayoutAmount": {
    "type": "internal",
    "function_name": "_setPayoutAmount()",
    "analysis_result": "This internal helper function is called to apply a previously queued payout amount change. It is only called from within the `claimFees` function when `queuedPayoutAmount` is non-zero.\n\n**Logic:**\n1.  It emits the `PayoutAmountSet` event, indicating the old `payoutAmount` and the new amount from `queuedPayoutAmount`.\n2.  It updates the storage variable `payoutAmount` with the value stored in `queuedPayoutAmount`.\n3.  It resets `queuedPayoutAmount` to 0.\n\n**Storage Variables Read:** `payoutAmount`, `queuedPayoutAmount`.\n\n**Storage Variables Modified:** `payoutAmount`, `queuedPayoutAmount`.\n\n**Events Emitted:** `PayoutAmountSet`."
  },
  "FeeCollector.onlyRole": {
    "type": "modifier",
    "function_name": "onlyRole(bytes32 role)",
    "analysis_result": "This modifier, inherited from `AccessControlUpgradeable`, restricts the decorated function's execution to only addresses that possess the specified `role`. It checks the caller's role using the internal `_checkRole` function. If the caller does not have the required role, it reverts with an `AccessControlUnauthorizedAccount` error."
  },
  "FeeCollector.whenNotPaused": {
    "type": "modifier",
    "function_name": "whenNotPaused",
    "analysis_result": "This modifier, inherited from `PausableUpgradeable`, restricts the decorated function's execution to only when the contract is *not* in a paused state. It checks the internal pause state. If the contract is paused, it reverts with a `PausablePaused` error."
  },
  "FeeCollector.initializer": {
    "type": "modifier",
    "function_name": "initializer",
    "analysis_result": "This modifier, from OpenZeppelin's upgradeable contracts (`Initializable.sol`), ensures that the function it decorates can only be called once. This is crucial for initializing state in upgradeable contracts after deployment via a proxy, preventing re-initialization attacks."
  },
  "BGTStaker.constructor": {
    "type": "public",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor for the proxy pattern implementation. It calls `_disableInitializers()` to prevent the `initialize` function from being called during the initial contract deployment (as it will be called via the proxy's `initialize`). It sets up the contract for being used as an upgradeable contract implementation. No storage variables are modified directly in this function, but it prepares the contract state for the initializer."
  },
  "BGTStaker.initialize": {
    "type": "external",
    "function_name": "initialize(address _bgt, address _feeCollector, address _governance, address _rewardToken)",
    "analysis_result": "This is the initializer function, meant to be called once through the proxy to set up the contract's initial state. It is marked with the `initializer` modifier. It initializes three inherited base contracts: `OwnableUpgradeable` with `_governance` as the initial owner, `StakingRewards` with `_bgt` as the staking token, `_rewardToken` as the reward token, and a default `rewardsDuration` of 7 days. It also initializes `UUPSUpgradeable`. Finally, it sets the contract's `FEE_COLLECTOR` storage variable to `_feeCollector`. Storage variables modified include `owner`, `stakeToken`, `rewardToken`, `rewardsDuration`, and `FEE_COLLECTOR`. It calls `__Ownable_init`, `__StakingRewards_init`, and `__UUPSUpgradeable_init`. Its purpose is to configure the core settings of the contract after deployment."
  },
  "BGTStaker.onlyBGT": {
    "type": "modifier",
    "function_name": "onlyBGT()",
    "analysis_result": "This custom modifier restricts the execution of a function to only the address specified as the staking token (`stakeToken`). It checks if `msg.sender` is equal to `address(stakeToken)`. If not, it reverts the transaction using a custom error `NotBGT` by checking its selector. This is used for `stake` and `withdraw` functions, implying they are designed to be called by the BGT token contract itself."
  },
  "BGTStaker.onlyFeeCollector": {
    "type": "modifier",
    "function_name": "onlyFeeCollector()",
    "analysis_result": "This custom modifier restricts the execution of a function to only the address stored in the `FEE_COLLECTOR` storage variable. It checks if `msg.sender` is equal to `FEE_COLLECTOR`. If not, it reverts the transaction using a custom error `NotFeeCollector` by checking its selector. This is used for the `notifyRewardAmount` function."
  },
  "BGTStaker._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This function is an override of the internal `_authorizeUpgrade` function from `UUPSUpgradeable`. It implements the authorization logic for contract upgrades, simply calling the `onlyOwner` modifier. This ensures that only the contract owner (set during initialization) can trigger a contract upgrade. It is protected by the `onlyOwner` modifier."
  },
  "BGTStaker.notifyRewardAmount": {
    "type": "external",
    "function_name": "notifyRewardAmount(uint256 reward)",
    "analysis_result": "This function allows the designated `FEE_COLLECTOR` to inform the staking contract about a new amount of reward tokens available for distribution. It is protected by the `onlyFeeCollector` modifier. It calls the internal `_notifyRewardAmount` function inherited from the `StakingRewards` base contract, passing the `reward` amount. `_notifyRewardAmount` handles the logic for calculating the new reward rate and updating the reward period, potentially modifying variables like `lastUpdateTime`, `rewardRate`, `periodFinish`, and `totalRewardPerTokenStored` in `StakingRewards`. Its purpose is to initiate the distribution of reward tokens to stakers."
  },
  "BGTStaker.recoverERC20": {
    "type": "external",
    "function_name": "recoverERC20(address tokenAddress, uint256 tokenAmount)",
    "analysis_result": "This function allows the contract `owner` to recover accidentally sent ERC20 tokens from the contract address. It is protected by the `onlyOwner` modifier. It checks if the `tokenAddress` is the same as the `rewardToken` address (from `StakingRewards`), reverting with `CannotRecoverRewardToken` if they match to protect reward funds. If not the reward token, it uses `SafeERC20.safeTransfer` to transfer the specified `tokenAmount` of the token at `tokenAddress` to the `owner`'s address. An event `Recovered` is emitted upon success. It reads `rewardToken` and `owner` storage variables."
  },
  "BGTStaker.setRewardsDuration": {
    "type": "external",
    "function_name": "setRewardsDuration(uint256 _rewardsDuration)",
    "analysis_result": "This function allows the contract `owner` to change the duration over which the notified rewards are distributed. It is protected by the `onlyOwner` modifier. It calls the internal `_setRewardsDuration` function inherited from the `StakingRewards` base contract, passing the new `_rewardsDuration`. `_setRewardsDuration` updates the `rewardsDuration` storage variable in `StakingRewards`. Its purpose is to adjust the reward distribution period."
  },
  "BGTStaker.stake": {
    "type": "external",
    "function_name": "stake(address account, uint256 amount)",
    "analysis_result": "This function is intended to be called by the staking token contract (BGT) itself, not directly by a user, as indicated by the `onlyBGT` modifier. It takes the `account` that is staking and the `amount` of BGT being staked. It calls the internal `_stake` function inherited from the `StakingRewards` base contract. `_stake` handles updating the total supply of staked tokens and the individual user's balance, potentially modifying `totalSupply` and `balances` in `StakingRewards`. Importantly, this function *does not* involve transferring BGT tokens into this contract due to the overrides of `_safeTransferFromStakeToken`. Staking here represents delegation or notification of staked balance elsewhere."
  },
  "BGTStaker.withdraw": {
    "type": "external",
    "function_name": "withdraw(address account, uint256 amount)",
    "analysis_result": "Similar to `stake`, this function is intended to be called by the staking token contract (BGT) itself, not directly by a user, as indicated by the `onlyBGT` modifier. It takes the `account` that is withdrawing and the `amount` of BGT being unstaked/undelegated. It calls the internal `_withdraw` function inherited from the `StakingRewards` base contract. `_withdraw` handles updating the total supply of staked tokens and the individual user's balance, potentially modifying `totalSupply` and `balances` in `StakingRewards`. As with `stake`, this function *does not* involve transferring BGT tokens out of this contract due to the overrides of `_safeTransferStakeToken`. Withdrawal here represents undelegation or notification of reduced staked balance elsewhere."
  },
  "BGTStaker.getReward": {
    "type": "external",
    "function_name": "getReward()",
    "analysis_result": "This function allows any caller (`msg.sender`) to claim their accumulated reward tokens. It calls the internal `_getReward` function inherited from the `StakingRewards` base contract. It passes `msg.sender` for both the account whose rewards are being claimed and the address to which the rewards should be sent. `_getReward` calculates the pending rewards for the user based on their stake and the reward rate, transfers the reward tokens using `safeTransfer` (which *is* active for the reward token), and updates the user's state to reflect that rewards have been claimed. It modifies variables related to user's claimed rewards and potentially reward calculations in `StakingRewards`. Its purpose is to enable users to claim earned reward tokens."
  },
  "BGTStaker._safeTransferFromStakeToken": {
    "type": "internal",
    "function_name": "_safeTransferFromStakeToken(address from, uint256 amount)",
    "analysis_result": "This function is an override of an internal function in the `StakingRewards` base contract. In `StakingRewards`, this function would typically perform an ERC20 transfer of the stake token from a user's address to the staking contract. However, in `BGTStaker`, this function is intentionally overridden to be empty (`{}`). This prevents actual BGT tokens from being transferred into this contract, facilitating a delegation/notification model rather than a deposit model. No storage variables are modified, and no other functions are called within this override."
  },
  "BGTStaker._safeTransferStakeToken": {
    "type": "internal",
    "function_name": "_safeTransferStakeToken(address to, uint256 amount)",
    "analysis_result": "This function is an override of an internal function in the `StakingRewards` base contract. In `StakingRewards`, this function would typically perform an ERC20 transfer of the stake token from the staking contract back to a user's address. However, in `BGTStaker`, this function is intentionally overridden to be empty (`{}`). This prevents actual BGT tokens from being transferred out of this contract during withdrawal, facilitating a delegation/notification model rather than a deposit model. No storage variables are modified, and no other functions are called within this override."
  },
  "BeaconDeposit.supportsInterface": {
    "type": "external",
    "function_name": "supportsInterface(bytes4 interfaceId) external pure override returns (bool)",
    "analysis_result": "This function implements the ERC165 interface. It checks if the contract supports the given interface ID. It returns `true` if the interface ID is either `type(ERC165).interfaceId` or `type(IBeaconDeposit).interfaceId`, indicating that the contract supports the ERC165 standard and the IBeaconDeposit custom interface. It does not read or modify any state variables as it is a pure function."
  },
  "BeaconDeposit.getOperator": {
    "type": "external",
    "function_name": "getOperator(bytes calldata pubkey) external view returns (address)",
    "analysis_result": "This function allows external callers to retrieve the current operator address associated with a specific validator public key. It takes a `bytes calldata pubkey` as input. It looks up the public key in the private mapping `_operatorByPubKey` and returns the corresponding address. If the public key is not found, it returns the zero address (address(0)). This function is a `view` function, meaning it does not modify the contract's state."
  },
  "BeaconDeposit.deposit": {
    "type": "external",
    "function_name": "deposit(bytes calldata pubkey, bytes calldata credentials, bytes calldata signature, address operator) external payable",
    "analysis_result": "This function handles the deposit of BERA (native token) to register a validator and link it to an operator address. It is a `payable` function, requiring native tokens to be sent with the transaction. It takes the validator's `pubkey` (48 bytes), `credentials` (32 bytes), `signature` (96 bytes), and an `operator` address as inputs. It performs length checks on `pubkey`, `credentials`, and `signature` against defined constants (`PUBLIC_KEY_LENGTH`, `CREDENTIALS_LENGTH`, `SIGNATURE_LENGTH`), reverting with specific error selectors if invalid lengths are provided.\n\nIt checks the `_operatorByPubKey` mapping to see if the `pubkey` has been registered before. If it's the first deposit for this `pubkey` (`_operatorByPubKey[pubkey]` is address(0)), it requires a non-zero `operator` address to be provided and sets `_operatorByPubKey[pubkey]` to this address, emitting an `OperatorUpdated` event. If it's not the first deposit for this `pubkey`, it requires the `operator` parameter to be the zero address (address(0)), reverting with `OperatorAlreadySet` otherwise, to prevent front-running of the operator assignment.\n\nIt calls the internal `_deposit()` function to process the attached `msg.value`, validate it is a multiple of Gwei and within `uint64` range, and transfer it to the zero address (simulating burning/sending to the consensus layer). It checks the returned `amountInGwei` from `_deposit()` against `MIN_DEPOSIT_AMOUNT_IN_GWEI` (10,000 Gwei), reverting with `InsufficientDeposit` if the amount is too low.\n\nFinally, it emits a `Deposit` event containing the `pubkey`, `credentials`, `amountInGwei`, `signature`, and the current `depositCount`. It then increments the public state variable `depositCount` by 1, which serves as a unique index for the deposit."
  },
  "BeaconDeposit.requestOperatorChange": {
    "type": "external",
    "function_name": "requestOperatorChange(bytes calldata pubkey, address newOperator) external",
    "analysis_result": "This function allows the current operator associated with a public key to initiate a request to change the operator to a `newOperator`. It takes the validator's `pubkey` and the desired `newOperator` address as inputs. It first retrieves the current operator address from the `_operatorByPubKey` mapping. It requires `msg.sender` to be equal to this current operator address, reverting with `NotOperator` if not (this check also implicitly verifies that the `pubkey` is registered and has a non-zero operator). It also requires the `newOperator` address not to be the zero address, reverting with `ZeroAddress` if it is.\n\nIt accesses the `QueuedOperator` struct associated with the `pubkey` in the `queuedOperator` mapping. It updates this struct's `newOperator` field to the provided `newOperator` and sets the `queuedTimestamp` to the current `block.timestamp`. This queues the operator change request. It then emits an `OperatorChangeQueued` event with the `pubkey`, `newOperator`, `currentOperator` (before the change), and the `block.timestamp` when the request was made.\n\nState variables modified: `queuedOperator`. State variables read: `_operatorByPubKey`, `queuedOperator`."
  },
  "BeaconDeposit.cancelOperatorChange": {
    "type": "external",
    "function_name": "cancelOperatorChange(bytes calldata pubkey) external",
    "analysis_result": "This function allows the current operator associated with a public key to cancel a pending operator change request for that public key. It takes the validator's `pubkey` as input. It verifies that `msg.sender` is the current operator for the `pubkey` by checking `_operatorByPubKey[pubkey]`, reverting with `NotOperator` if not. If the caller is the current operator, it deletes the entry for the `pubkey` in the `queuedOperator` mapping. This effectively removes the queued request.\n\nAfter successful cancellation, it emits an `OperatorChangeCancelled` event with the `pubkey`. State variables modified: `queuedOperator`. State variables read: `_operatorByPubKey`, `queuedOperator`."
  },
  "BeaconDeposit.acceptOperatorChange": {
    "type": "external",
    "function_name": "acceptOperatorChange(bytes calldata pubkey) external",
    "analysis_result": "This function allows the *proposed* new operator to accept a previously queued operator change request for a given `pubkey`. It takes the validator's `pubkey` as input. It retrieves the queued request data (`newOperator` and `queuedTimestamp`) from the `queuedOperator` mapping. It performs several checks:\n\n1.  Requires `msg.sender` to be equal to the `newOperator` stored in the queued request. Reverts with `NotNewOperator` if not (this also covers cases where no request is queued, as `newOperator` would be address(0)).\n2.  Checks if sufficient time (at least `ONE_DAY` seconds) has passed since the request was queued (`queuedTimestamp + ONE_DAY <= block.timestamp`). Reverts with `NotEnoughTime` if the delay has not passed.\n\nIf these checks pass, it proceeds to update the operator. It reads the current operator from `_operatorByPubKey` (the 'old' operator). It then updates `_operatorByPubKey[pubkey]` to the `newOperator` from the queued request. Finally, it deletes the entry for the `pubkey` in the `queuedOperator` mapping, clearing the request. An `OperatorUpdated` event is emitted with the `pubkey`, the new operator, and the old operator.\n\nState variables modified: `_operatorByPubKey`, `queuedOperator`. State variables read: `queuedOperator`, `_operatorByPubKey`."
  },
  "BeaconDeposit._deposit": {
    "type": "internal",
    "function_name": "_deposit() internal virtual returns (uint64)",
    "analysis_result": "This internal helper function is called by the `deposit` function to handle the processing of the native token value sent with the deposit. It first checks if `msg.value` (the amount of native token sent) is a multiple of 1 Gwei, reverting with `DepositNotMultipleOfGwei` if it's not precise to the Gwei unit. It calculates the amount in Gwei by dividing `msg.value` by 1 Gwei. It checks if this amount exceeds the maximum value representable by a `uint64`, reverting with `DepositValueTooHigh` if it does.\n\nIt then calls the internal `_safeTransferETH` function to transfer the original `msg.value` to the zero address (`address(0)`). This is a standard pattern in consensus layer deposit contracts to effectively remove the tokens from the execution layer and signal them for use on the consensus layer. Finally, it returns the validated deposit amount converted to `uint64` in Gwei. It reads no state variables and modifies none directly, but calls `_safeTransferETH` which handles the ETH transfer."
  },
  "BeaconDeposit._safeTransferETH": {
    "type": "internal",
    "function_name": "_safeTransferETH(address to, uint256 amount) internal",
    "analysis_result": "This internal helper function is used to safely transfer a specified `amount` of native token to a target address `to` using a low-level `call`. It's designed to handle potential failures of the transfer call. It uses an assembly block to perform the `call`. If the `call` returns a zero success indicator, the function reverts with a specific error selector (`ETHTransferFailed()`). In this contract, it is specifically used by `_deposit` to send the deposited amount to `address(0)`. It does not read or modify any state variables."
  },
  "BGT.onlyBlockRewardController": {
    "type": "modifier",
    "function_name": "onlyBlockRewardController()",
    "analysis_result": "This modifier restricts access to a function, allowing it to be called only by the address stored in the `_blockRewardController` state variable. It checks if `msg.sender` is equal to `_blockRewardController`. If not, it reverts with the custom error `NotBlockRewardController` using its selector."
  },
  "BGT.onlyApprovedSender": {
    "type": "modifier",
    "function_name": "onlyApprovedSender(address sender)",
    "analysis_result": "This modifier restricts access to a function, allowing it to be called only if the provided `sender` address is whitelisted in the `isWhitelistedSender` mapping. It checks `isWhitelistedSender[sender]`. If the sender is not whitelisted (the value is false), it reverts with the custom error `NotApprovedSender` using its selector. It uses the state variable `isWhitelistedSender`."
  },
  "BGT.checkUnboostedBalance": {
    "type": "modifier",
    "function_name": "checkUnboostedBalance(address sender, uint256 amount)",
    "analysis_result": "This modifier checks if the unboosted balance of the `sender` address is greater than or equal to the specified `amount`. It calls the internal helper function `_checkUnboostedBalance` with the `sender` and `amount`. If the check fails (unboosted balance is insufficient), the helper function will revert with `NotEnoughBalance`. It uses the state variable `userBoosts` indirectly via `unboostedBalanceOf`."
  },
  "BGT.invariantCheck": {
    "type": "modifier",
    "function_name": "invariantCheck()",
    "analysis_result": "This modifier is intended to check contract invariants after a state-changing operation. It executes the function body first (`_;`). After the function body successfully completes, it calls the private helper function `_invariantCheck`. This helper function checks if the contract's ETH balance (`address(this).balance`) is less than the total BGT supply (`totalSupply()`). If this invariant is violated, it reverts with the custom error `InvariantCheckFailed`. It uses the state variable `totalSupply` indirectly via `_invariantCheck` and checks the contract's own balance."
  },
  "BGT.initialize": {
    "type": "external",
    "function_name": "initialize(address _owner)",
    "analysis_result": "This function is an initializer, designed to be called only once by the deployer (via OpenZeppelin's `initializer` modifier, although the code comment says it's not upgradable, it uses upgradeable base contracts and the `initializer` pattern). It sets up the contract's initial state. It calls the initializer for `OwnableUpgradeable` (`__Ownable_init(_owner)`) to set the contract owner to `_owner`. It calls the initializer for `ERC20Upgradeable` (`__ERC20_init(NAME, SYMBOL)`) to set the token name and symbol using the private constants `NAME` and `SYMBOL`. It sets the `activateBoostDelay` and `dropBoostDelay` state variables to the value of the private constant `BOOST_MAX_BLOCK_DELAY`. It modifies the state variables `owner`, `_name`, `_symbol`, `activateBoostDelay`, and `dropBoostDelay`."
  },
  "BGT.whitelistSender": {
    "type": "external",
    "function_name": "whitelistSender(address sender, bool approved)",
    "analysis_result": "This function allows the contract owner to add or remove an address from the list of approved senders. It is restricted to the owner by the `onlyOwner` modifier (inherited from `OwnableUpgradeable`). It takes an address `sender` and a boolean `approved`. It updates the `isWhitelistedSender` mapping for the given `sender` with the value of `approved`. It emits the `SenderWhitelisted` event with the `sender` and `approved` status. It uses and modifies the state variable `isWhitelistedSender`."
  },
  "BGT.setMinter": {
    "type": "external",
    "function_name": "setMinter(address _minter)",
    "analysis_result": "This function allows the contract owner to set the address of the BlockRewardController, which is the only contract authorized to mint BGT. It is restricted to the owner by the `onlyOwner` modifier. It takes an address `_minter`. It checks if `_minter` is the zero address; if so, it reverts with the custom error `ZeroAddress`. It emits the `MinterChanged` event with the old and new minter addresses (`_blockRewardController` and `_minter`). It updates the `_blockRewardController` state variable. It uses and modifies the state variable `_blockRewardController`."
  },
  "BGT.mint": {
    "type": "external",
    "function_name": "mint(address distributor, uint256 amount)",
    "analysis_result": "This function allows the minting of BGT tokens. It is restricted to the BlockRewardController address by the `onlyBlockRewardController` modifier. It is also subject to the `invariantCheck` modifier, which runs after the minting operation to ensure the contract's ETH balance invariant is maintained. It takes a `distributor` address (the recipient of the minted tokens) and the `amount` to mint. It calls the inherited internal function `super._mint(distributor, amount)` from `ERC20Upgradeable` to perform the minting. It modifies the total supply and the recipient's balance state variables within `_mint`. It uses and modifies internal state variables related to ERC20 balances and total supply via the `_mint` call."
  },
  "BGT.setStaker": {
    "type": "external",
    "function_name": "setStaker(address _staker)",
    "analysis_result": "This function allows the contract owner to set the address of the BGTStaker contract, which is used for staking and withdrawing BGT related to validator boosts. It is restricted to the owner by the `onlyOwner` modifier. It takes an address `_staker`. It checks if `_staker` is the zero address; if so, it reverts with the custom error `ZeroAddress`. It emits the `StakerChanged` event with the old and new staker addresses (`staker` and `_staker`). It updates the `staker` state variable. It uses and modifies the state variable `staker`."
  },
  "BGT.setActivateBoostDelay": {
    "type": "external",
    "function_name": "setActivateBoostDelay(uint32 _activateBoostDelay)",
    "analysis_result": "This function allows the contract owner to set the minimum block delay required before a queued boost can be activated. It is restricted to the owner by the `onlyOwner` modifier. It takes a `uint32 _activateBoostDelay`. It checks if `_activateBoostDelay` is 0 or greater than `BOOST_MAX_BLOCK_DELAY`; if so, it reverts with the custom error `InvalidActivateBoostDelay`. Otherwise, it updates the `activateBoostDelay` state variable. It emits the `ActivateBoostDelayChanged` event with the new delay value. It uses and modifies the state variable `activateBoostDelay` and uses the constant `BOOST_MAX_BLOCK_DELAY`."
  },
  "BGT.setDropBoostDelay": {
    "type": "external",
    "function_name": "setDropBoostDelay(uint32 _dropBoostDelay)",
    "analysis_result": "This function allows the contract owner to set the minimum block delay required before a queued drop boost can be finalized. It is restricted to the owner by the `onlyOwner` modifier. It takes a `uint32 _dropBoostDelay`. It checks if `_dropBoostDelay` is 0 or greater than `BOOST_MAX_BLOCK_DELAY`; if so, it reverts with the custom error `InvalidDropBoostDelay`. Otherwise, it updates the `dropBoostDelay` state variable. It emits the `DropBoostDelayChanged` event with the new delay value. It uses and modifies the state variable `dropBoostDelay` and uses the constant `BOOST_MAX_BLOCK_DELAY`."
  },
  "BGT.setBgtTermsAndConditions": {
    "type": "external",
    "function_name": "setBgtTermsAndConditions(string calldata _bgtTermsAndConditions)",
    "analysis_result": "This function allows the contract owner to set or update the BGT terms and conditions string. It is restricted to the owner by the `onlyOwner` modifier. It takes a `string calldata _bgtTermsAndConditions`. It updates the `bgtTermsAndConditions` state variable with the provided string. It emits the `BgtTermsAndConditionsChanged` event with the new terms string. It uses and modifies the state variable `bgtTermsAndConditions`."
  },
  "BGT.queueBoost": {
    "type": "external",
    "function_name": "queueBoost(bytes calldata pubkey, uint128 amount)",
    "analysis_result": "This function allows a user to queue a certain `amount` of their BGT balance to be used for boosting a specific validator identified by `pubkey`. It is restricted by the `checkUnboostedBalance` modifier, ensuring the sender has enough unboosted BGT. It adds the `amount` to the sender's total queued boost balance in `userBoosts[msg.sender].queuedBoost`. It then updates the `boostedQueue` mapping for the sender and pubkey, adding the `amount` to the `balance` and updating the `blockNumberLast` to the current block number (`uint32(block.number)`). It emits the `QueueBoost` event with the sender, pubkey, and amount. It uses and modifies the state variables `userBoosts` and `boostedQueue`."
  },
  "BGT.cancelBoost": {
    "type": "external",
    "function_name": "cancelBoost(bytes calldata pubkey, uint128 amount)",
    "analysis_result": "This function allows a user to cancel a previously queued boost of a specific `amount` for a validator identified by `pubkey`. It subtracts the `amount` from the queued boost balance in the `boostedQueue` mapping for the sender and pubkey (`boostedQueue[msg.sender][pubkey].balance`). It also subtracts the `amount` from the sender's total queued boost balance in `userBoosts[msg.sender].queuedBoost`. It uses unchecked arithmetic for subtraction, assuming the amount being cancelled does not exceed the queued amount (which should be guaranteed by the logic that adds to these variables). It emits the `CancelBoost` event with the sender, pubkey, and amount. It uses and modifies the state variables `boostedQueue` and `userBoosts`."
  },
  "BGT.activateBoost": {
    "type": "external",
    "function_name": "activateBoost(address user, bytes calldata pubkey)",
    "analysis_result": "This function allows activation of a queued boost for a specific `user` and validator `pubkey` after the required block delay has passed. It is typically called by a third party (potentially an approved sender, though not enforced by modifier here, Multicallable context might imply this) to help users finalize boosts. It retrieves the queued boost information (`blockNumberLast` and `amount`) from `boostedQueue[user][pubkey]`. It checks if the `amount` is greater than 0 and if enough blocks have passed since `blockNumberLast` by calling the internal helper function `_checkEnoughTimePassed` with `blockNumberLast` and `activateBoostDelay`. If either condition is false, it returns `false`. If conditions are met, it adds the `amount` to the `totalBoosts`, `boostees[pubkey]`, and `boosted[user][pubkey]` state variables. It also updates the sender's `userBoosts[user]` by adding `amount` to `boost` and subtracting `amount` from `queuedBoost`. It uses unchecked arithmetic for these updates, assuming the queued amount is available in the queued balance. It deletes the entry in `boostedQueue[user][pubkey]`. It then calls the `stake` function on the contract address stored in `staker` (expected to be the `IBGTStaker` contract), passing the `user` and `amount`. Finally, it emits the `ActivateBoost` event with the caller (`msg.sender`), the user, pubkey, and amount, and returns `true`. It uses and modifies `totalBoosts`, `boostees`, `boosted`, `userBoosts`, `boostedQueue`, `activateBoostDelay`, and calls an external contract via the `staker` address."
  },
  "BGT.queueDropBoost": {
    "type": "external",
    "function_name": "queueDropBoost(bytes calldata pubkey, uint128 amount)",
    "analysis_result": "This function allows a user to queue a certain `amount` of their currently boosted BGT balance to be dropped for a specific validator identified by `pubkey`. It calculates the new drop balance (`dropBalance`) by adding the `amount` to the current queued drop balance for the sender and pubkey (`dropBoostQueue[msg.sender][pubkey].balance`). It checks if the sender has enough currently boosted balance for that validator (`boosted[msg.sender][pubkey]`) to cover the `dropBalance`. If not, it reverts with the custom error `NotEnoughBoostedBalance`. If the check passes, it updates the `dropBoostQueue` mapping for the sender and pubkey, setting the `balance` to `dropBalance` and updating the `blockNumberLast` to the current block number (`uint32(block.number)`). It emits the `QueueDropBoost` event with the sender, pubkey, and amount. It uses and modifies the state variable `dropBoostQueue` and reads from `boosted`."
  },
  "BGT.cancelDropBoost": {
    "type": "external",
    "function_name": "cancelDropBoost(bytes calldata pubkey, uint128 amount)",
    "analysis_result": "This function allows a user to cancel a previously queued drop boost of a specific `amount` for a validator identified by `pubkey`. It subtracts the `amount` from the queued drop boost balance in the `dropBoostQueue` mapping for the sender and pubkey (`dropBoostQueue[msg.sender][pubkey].balance`). It uses unchecked arithmetic for the subtraction, assuming the amount being cancelled does not exceed the queued amount. It emits the `CancelDropBoost` event with the sender, pubkey, and amount. It uses and modifies the state variable `dropBoostQueue`."
  },
  "BGT.dropBoost": {
    "type": "external",
    "function_name": "dropBoost(address user, bytes calldata pubkey)",
    "analysis_result": "This function allows finalizing a queued drop boost for a specific `user` and validator `pubkey` after the required block delay has passed. It is typically called by a third party (potentially an approved sender). It retrieves the queued drop boost information (`blockNumberLast` and `amount`) from `dropBoostQueue[user][pubkey]`. It checks if the `amount` is greater than 0 and if enough blocks have passed since `blockNumberLast` by calling the internal helper function `_checkEnoughTimePassed` with `blockNumberLast` and `dropBoostDelay`. If either condition is false, it returns `false`. If conditions are met, it subtracts the `amount` from `boosted[user][pubkey]`, `totalBoosts`, and `userBoosts[user].boost`. It also subtracts the amount from `boostees[pubkey]`. It uses unchecked arithmetic for these updates, assuming the amount being dropped is available in the boosted and queued drop balances (checked in `queueDropBoost`). It deletes the entry in `dropBoostQueue[user][pubkey]`. It then calls the `withdraw` function on the contract address stored in `staker` (expected to be the `IBGTStaker` contract), passing the `user` and `amount`. Finally, it emits the `DropBoost` event with the caller (`msg.sender`), the user, pubkey, and amount, and returns `true`. It uses and modifies `boosted`, `totalBoosts`, `userBoosts`, `boostees`, `dropBoostQueue`, `dropBoostDelay`, and calls an external contract via the `staker` address."
  },
  "BGT.approve": {
    "type": "public",
    "function_name": "approve(address spender, uint256 amount)",
    "analysis_result": "This function allows a user to approve a `spender` address to withdraw a specific `amount` of tokens on their behalf. It overrides the standard ERC20 `approve` function. It is restricted by the `onlyApprovedSender` modifier, meaning only addresses whitelisted as senders can call this function. It calls the inherited `super.approve(spender, amount)` from `ERC20Upgradeable` to perform the standard ERC20 approval logic, which updates the allowance mapping. It returns a boolean indicating success. It uses the state variable `isWhitelistedSender` via the modifier and internal state variables related to ERC20 allowances via the `super.approve` call."
  },
  "BGT.transfer": {
    "type": "public",
    "function_name": "transfer(address to, uint256 amount)",
    "analysis_result": "This function allows a user to transfer a specific `amount` of tokens from their balance to a `to` address. It overrides the standard ERC20 `transfer` function. It is restricted by the `onlyApprovedSender` modifier, meaning only whitelisted senders can call this function. It is further restricted by the `checkUnboostedBalance` modifier, ensuring the sender has enough *unboosted* BGT balance to cover the `amount`. It calls the inherited `super.transfer(to, amount)` from `ERC20Upgradeable` to perform the standard ERC20 transfer logic, which updates balances. It returns a boolean indicating success. It uses the state variable `isWhitelistedSender` via `onlyApprovedSender`, `userBoosts` via `checkUnboostedBalance`, and internal state variables related to ERC20 balances via the `super.transfer` call."
  },
  "BGT.transferFrom": {
    "type": "public",
    "function_name": "transferFrom(address from, address to, uint256 amount)",
    "analysis_result": "This function allows a `spender` (caller) to transfer a specific `amount` of tokens from the `from` address to the `to` address, provided the `spender` has sufficient allowance from `from`. It overrides the standard ERC20 `transferFrom` function. It is restricted by the `onlyApprovedSender` modifier, meaning the `from` address (not the caller) must be whitelisted as a sender. It is further restricted by the `checkUnboostedBalance` modifier, ensuring the `from` address has enough *unboosted* BGT balance. It calls the inherited `super.transferFrom(from, to, amount)` from `ERC20Upgradeable` to perform the standard ERC20 transferFrom logic, which checks allowance, updates balances, and reduces allowance. It returns a boolean indicating success. It uses the state variable `isWhitelistedSender` via `onlyApprovedSender`, `userBoosts` via `checkUnboostedBalance`, and internal state variables related to ERC20 balances and allowances via the `super.transferFrom` call."
  },
  "BGT.redeem": {
    "type": "external",
    "function_name": "redeem(address receiver, uint256 amount)",
    "analysis_result": "This function allows a user (`msg.sender`) to redeem a specific `amount` of their BGT tokens for the contract's native token (ETH). It is restricted by the `checkUnboostedBalance` modifier, ensuring the sender has enough unboosted BGT to redeem. It is also subject to the `invariantCheck` modifier, ensuring the contract's ETH balance invariant is maintained after the operation. It calls the inherited internal function `super._burn(msg.sender, amount)` from `ERC20Upgradeable` to burn the BGT from the sender's account, reducing supply and balance. It then calls `SafeTransferLib.safeTransferETH(receiver, amount)` to transfer the corresponding `amount` of native token from the contract's balance to the `receiver` address. It emits the `Redeem` event with the sender, receiver, and amount. It uses the state variable `userBoosts` via `checkUnboostedBalance`, and internal state variables related to ERC20 balances and total supply via `_burn`. It also relies on the contract's native token balance."
  },
  "BGT.burnExceedingReserves": {
    "type": "external",
    "function_name": "burnExceedingReserves()",
    "analysis_result": "This function allows anyone to trigger a burn of excess native token (ETH) held by the contract. The contract is intended to hold enough native token to back the total supply of BGT plus a buffer for potential future mints (based on `HISTORY_BUFFER_LENGTH` and the max BGT per block). It calculates the `potentialMintableBGT` based on `HISTORY_BUFFER_LENGTH` and the max BGT per block obtained by calling `getMaxBGTPerBlock` on the `_blockRewardController` contract. It calculates the `outstandingRequiredAmount` as the sum of the current total supply and the `potentialMintableBGT`. It then gets the contract's current native token balance (`currentReservesAmount`). If `currentReservesAmount` is not greater than `outstandingRequiredAmount`, the function returns without doing anything. If there is an excess (`currentReservesAmount > outstandingRequiredAmount`), it calculates the `excessAmountToBurn` and transfers this amount to the zero address (`address(0)`) using `SafeTransferLib.safeTransferETH(address(0), excessAmountToBurn)`, effectively burning it. It emits the `ExceedingReservesBurnt` event with the caller and the amount burned. It uses the state variables `_blockRewardController` and the internal state variable for total supply (`totalSupply()`) and relies on the contract's native token balance. It calls an external contract via the `_blockRewardController` address."
  },
  "BGT.minter": {
    "type": "external",
    "function_name": "minter()",
    "analysis_result": "This getter function returns the address currently set as the BlockRewardController, which is authorized to mint BGT. It is a `view` function and returns the value of the `_blockRewardController` state variable."
  },
  "BGT.normalizedBoost": {
    "type": "external",
    "function_name": "normalizedBoost(bytes calldata pubkey)",
    "analysis_result": "This getter function calculates and returns the normalized boost value for a specific validator identified by `pubkey`. The normalized boost represents the proportion of the total active boosts that is attributed to this specific validator. It checks if `totalBoosts` is 0; if so, it returns 0 to avoid division by zero. Otherwise, it calculates the normalized boost by dividing the validator's total boost (`boostees[pubkey]`) by the total active boosts (`totalBoosts`) using the `FixedPointMathLib.divWad` function, which handles fixed-point division. It uses the state variables `totalBoosts` and `boostees` and the `FixedPointMathLib` library."
  },
  "BGT.boosts": {
    "type": "external",
    "function_name": "boosts(address account)",
    "analysis_result": "This getter function returns the total active boosted BGT balance for a specific `account`. It is a `view` function and returns the `boost` value from the `UserBoost` struct stored in `userBoosts[account].boost`. It uses the state variable `userBoosts`."
  },
  "BGT.queuedBoost": {
    "type": "external",
    "function_name": "queuedBoost(address account)",
    "analysis_result": "This getter function returns the total queued boost balance (waiting to be activated) for a specific `account`. It is a `view` function and returns the `queuedBoost` value from the `UserBoost` struct stored in `userBoosts[account].queuedBoost`. It uses the state variable `userBoosts`."
  },
  "BGT.name": {
    "type": "public",
    "function_name": "name()",
    "analysis_result": "This function returns the name of the ERC20 token. It is a `pure` function, overriding inherited `name()` functions from `IERC20Metadata` and `ERC20Upgradeable`. It simply returns the private constant string `NAME`."
  },
  "BGT.symbol": {
    "type": "public",
    "function_name": "symbol()",
    "analysis_result": "This function returns the symbol of the ERC20 token. It is a `pure` function, overriding inherited `symbol()` functions from `IERC20Metadata` and `ERC20Upgradeable`. It simply returns the private constant string `SYMBOL`."
  },
  "BGT.unboostedBalanceOf": {
    "type": "public",
    "function_name": "unboostedBalanceOf(address account)",
    "analysis_result": "This getter function calculates and returns the 'unboosted' balance of a specific `account`. The unboosted balance is defined as the account's total BGT balance minus their total active boosted balance and their total queued boost balance. It retrieves the account's total balance by calling the inherited `balanceOf(account)`. It retrieves the active boost (`boost`) and queued boost (`_queuedBoost`) from the `userBoosts[account]` struct. It subtracts the boost and queued boost from the total balance. It uses the state variable `userBoosts` and the inherited `balanceOf` function."
  },
  "BGT.clock": {
    "type": "public",
    "function_name": "clock()",
    "analysis_result": "This function implements the `clock()` function required by the `IERC6372` interface. It returns a `uint48` representing the current timestamp. It calls `Time.timestamp()` from the imported OpenZeppelin `Time` library to get the current block timestamp."
  },
  "BGT.CLOCK_MODE": {
    "type": "public",
    "function_name": "CLOCK_MODE()",
    "analysis_result": "This function implements the `CLOCK_MODE()` function required by the `IERC6372` interface. It returns a string describing the clock mode used. It is a `pure` function and returns the string \"mode=timestamp\"."
  },
  "BGT._checkUnboostedBalance": {
    "type": "private",
    "function_name": "_checkUnboostedBalance(address sender, uint256 amount)",
    "analysis_result": "This internal helper function checks if the unboosted balance of a `sender` is sufficient for a given `amount`. It calls the public getter function `unboostedBalanceOf(sender)` to get the sender's unboosted balance. If the unboosted balance is less than the `amount`, it reverts with the custom error `NotEnoughBalance` using its selector. It uses the state variable `userBoosts` indirectly via `unboostedBalanceOf`."
  },
  "BGT._checkEnoughTimePassed": {
    "type": "private",
    "function_name": "_checkEnoughTimePassed(uint32 blockNumberLast, uint32 blockBufferDelay)",
    "analysis_result": "This internal helper function checks if enough blocks have passed since a specific block number (`blockNumberLast`) compared to a required delay (`blockBufferDelay`). It calculates the block difference (`delta`) using `uint32(block.number) - blockNumberLast` within an unchecked block to prevent overflow/underflow reverts for typical use cases (block numbers increase sequentially). If the `delta` is less than or equal to `blockBufferDelay`, it means not enough time has passed, and it returns `false`. Otherwise, it returns `true`. It uses the block.number global variable."
  },
  "BGT._invariantCheck": {
    "type": "private",
    "function_name": "_invariantCheck()",
    "analysis_result": "This internal helper function checks a critical contract invariant: that the contract's native token (ETH) balance is not less than the total supply of BGT. It compares `address(this).balance` with the result of `totalSupply()`. If `address(this).balance` is less than `totalSupply()`, it means the contract does not hold enough native token to back the BGT supply, and it reverts with the custom error `InvariantCheckFailed` using its selector. It uses the internal state variable for total supply (`totalSupply()`) and relies on the contract's native token balance."
  },
  "BGTFeeDeployer.constructor": {
    "type": "constructor",
    "function_name": "constructor(address bgt, address governance, address rewardToken, uint256 bgtStakerSalt, uint256 feeCollectorSalt, uint256 payoutAmount)",
    "analysis_result": "This is the constructor for the BGTFeeDeployer contract. Its purpose is to deploy and initialize the BGTStaker and FeeCollector contracts using the CREATE2 opcode. It takes six parameters: `bgt` (address of the BGT token), `governance` (address of the governance contract), `rewardToken` (address of the reward token), `bgtStakerSalt` (salt for the BGTStaker proxy deployment), `feeCollectorSalt` (salt for the FeeCollector proxy deployment), and `payoutAmount` (initial payout amount for the FeeCollector).  The constructor first uses the inherited `deployWithCreate2` function (presumably from `Create2Deployer`) to deploy the *implementation* contract of `BGTStaker` using its creation code and a salt of 0. It then uses the inherited `deployProxyWithCreate2` function to deploy the *proxy* contract for `BGTStaker`, using the previously deployed implementation address and the provided `bgtStakerSalt`. The address of the deployed BGTStaker proxy is cast to the `BGTStaker` type and assigned to the `bgtStaker` immutable state variable.  The same process is repeated for the `FeeCollector` contract: its implementation is deployed with salt 0 using `deployWithCreate2`, and its proxy is deployed using the implementation address and the provided `feeCollectorSalt` via `deployProxyWithCreate2`. The address of the deployed FeeCollector proxy is cast to the `FeeCollector` type and assigned to the `feeCollector` immutable state variable.  Finally, the constructor calls the `initialize` function on both the newly deployed `bgtStaker` and `feeCollector` proxy contracts to set up their initial state. The `bgtStaker.initialize` call receives the `bgt` token address, the address of the `feeCollector` contract, the `governance` address, and the `rewardToken` address. The `feeCollector.initialize` call receives the `governance` address, the `rewardToken` address, the address of the `bgtStaker` contract, and the `payoutAmount`. This function modifies the immutable state variables `bgtStaker` and `feeCollector` by assigning them the addresses of the deployed proxy contracts."
  },
  "RewardVault.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "The constructor for the `RewardVault` contract. It is marked with `/// @custom:oz-upgrades-unsafe-allow constructor` and calls `_disableInitializers()`. This is a standard pattern for upgradeable contracts using the OpenZeppelin Upgrades plugin, ensuring that the `initialize` function must be called instead of the constructor for initial setup after deployment."
  },
  "RewardVault.initialize": {
    "type": "external",
    "function_name": "initialize(address _beaconDepositContract, address _bgt, address _distributor, address _stakingToken)",
    "analysis_result": "This is the initializer function for the upgradeable contract, called once after deployment. It takes the addresses of the `beaconDepositContract`, `bgt` (reward token), `distributor`, and `stakingToken` as parameters. It calls initializers for inherited contracts: `__FactoryOwnable_init(msg.sender)`, `__Pausable_init()`, `__ReentrancyGuard_init()`, and `__StakingRewards_init(_stakingToken, _bgt, 3 days)`. It sets the `maxIncentiveTokensCount` to 3, `distributor` to `_distributor` (includes a `slither-disable-next-line missing-zero-check`), and `beaconDepositContract` to the provided address. It emits the `DistributorSet` and `MaxIncentiveTokensCountUpdated` events. Storage variables modified: `owner` (via `__FactoryOwnable_init`), `_paused` (via `__Pausable_init`), `_notEntered` (via `__ReentrancyGuard_init`), `stakeToken`, `rewardToken`, `rewardsDuration` (via `__StakingRewards_init`), `maxIncentiveTokensCount`, `distributor`, `beaconDepositContract`. Requires the `initializer` modifier."
  },
  "RewardVault.onlyDistributor": {
    "type": "modifier",
    "function_name": "onlyDistributor()",
    "analysis_result": "This modifier checks if the `msg.sender` is equal to the stored `distributor` address. If not, it reverts with the `NotDistributor` error selector. It is used to restrict access to functions that should only be callable by the designated distributor contract."
  },
  "RewardVault.onlyOperatorOrUser": {
    "type": "modifier",
    "function_name": "onlyOperatorOrUser(address account)",
    "analysis_result": "This modifier checks if the `msg.sender` is either the `account` itself or the operator address stored for that `account` in the `_operators` mapping. If neither condition is met, it reverts with the `NotOperator` error selector. It is used to control access to functions that can be called by an account or its designated operator."
  },
  "RewardVault.checkSelfStakedBalance": {
    "type": "modifier",
    "function_name": "checkSelfStakedBalance(address account, uint256 amount)",
    "analysis_result": "This modifier calls the internal function `_checkSelfStakedBalance(account, amount)` to verify that the specified `account` has a sufficient self-staked balance (total stake minus stake delegated by others) to cover the requested `amount`. It is used to ensure that withdrawal amounts do not exceed the portion of stake that was directly staked by the user."
  },
  "RewardVault.onlyWhitelistedToken": {
    "type": "modifier",
    "function_name": "onlyWhitelistedToken(address token)",
    "analysis_result": "This modifier checks if the provided `token` address is whitelisted as an incentive token. It does this by looking up the token in the `incentives` mapping and checking if its `minIncentiveRate` is non-zero. If the token is not whitelisted, it reverts with the `TokenNotWhitelisted` error selector. It is used to restrict operations related to incentive tokens to only those that have been explicitly whitelisted."
  },
  "RewardVault.setDistributor": {
    "type": "external",
    "function_name": "setDistributor(address _rewardDistribution)",
    "analysis_result": "Allows the factory owner to set a new address for the `distributor` contract. It requires the `_rewardDistribution` address to be non-zero. Updates the `distributor` storage variable and emits the `DistributorSet` event. Storage variables modified: `distributor`. Requires the `onlyFactoryOwner` modifier (inherited)."
  },
  "RewardVault.notifyRewardAmount": {
    "type": "external",
    "function_name": "notifyRewardAmount(bytes calldata pubkey, uint256 reward)",
    "analysis_result": "This function is called by the `distributor` to notify the contract about a new reward amount (`reward`) for a specific validator identified by their `pubkey`. It first calls the inherited `_notifyRewardAmount(reward)` from `StakingRewards` to update the BGT reward state. Then, it calls the internal `_processIncentives(pubkey, reward)` function to handle the distribution of whitelisted incentive tokens based on this BGT emission. Storage variables modified: `rewardRate`, `lastUpdateTime`, `rewardPerTokenStored`, `undistributedRewards` (via `_notifyRewardAmount`), `incentives[token].amountRemaining` (via `_processIncentives`). Requires the `onlyDistributor` modifier."
  },
  "RewardVault.recoverERC20": {
    "type": "external",
    "function_name": "recoverERC20(address tokenAddress, uint256 tokenAmount)",
    "analysis_result": "Allows the factory owner to recover accidental ERC20 token transfers to the contract. It takes the `tokenAddress` and `tokenAmount` to recover. It explicitly prevents recovering the `stakeToken` or any token that is currently whitelisted as an incentive token by checking `incentives[tokenAddress].minIncentiveRate != 0`. It uses `SafeERC20.safeTransfer` to send the `tokenAmount` of `tokenAddress` to `msg.sender`. Emits the `Recovered` event. Storage variables read: `stakeToken`, `incentives`. Requires the `onlyFactoryOwner` modifier (inherited)."
  },
  "RewardVault.setRewardsDuration": {
    "type": "external",
    "function_name": "setRewardsDuration(uint256 _rewardsDuration)",
    "analysis_result": "Allows the factory owner to set a new duration for the reward distribution period. It calls the inherited `_setRewardsDuration(_rewardsDuration)` from `StakingRewards`. This function might affect the calculated reward rate. Storage variables modified: `rewardsDuration` (via `_setRewardsDuration`). Requires the `onlyFactoryOwner` modifier (inherited)."
  },
  "RewardVault.whitelistIncentiveToken": {
    "type": "external",
    "function_name": "whitelistIncentiveToken(address token, uint256 minIncentiveRate, address manager)",
    "analysis_result": "Allows the factory owner to add a new token to the list of whitelisted incentive tokens. It takes the `token` address, a `minIncentiveRate` (minimum amount per BGT emission), and the `manager` address responsible for adding this token. It validates that `minIncentiveRate` is non-zero and within `MAX_INCENTIVE_RATE`, and that `token` and `manager` addresses are non-zero. It checks if the `maxIncentiveTokensCount` limit has been reached or if the token is already whitelisted. It pushes the `token` to the `whitelistedTokens` array, sets the initial `incentiveRate` and `minIncentiveRate` for the token in the `incentives` mapping, and sets the `manager`. Emits the `IncentiveTokenWhitelisted` event. Storage variables modified: `incentives`, `whitelistedTokens`. Storage variables read: `maxIncentiveTokensCount`. Requires the `onlyFactoryOwner` modifier (inherited)."
  },
  "RewardVault.removeIncentiveToken": {
    "type": "external",
    "function_name": "removeIncentiveToken(address token)",
    "analysis_result": "Allows the factory vault manager to remove a token from the whitelisted incentive tokens list. It requires the `token` to be currently whitelisted using the `onlyWhitelistedToken` modifier. It deletes the token's data from the `incentives` mapping and calls the internal helper `_deleteWhitelistedTokenFromList(token)` to remove it from the `whitelistedTokens` array. Emits the `IncentiveTokenRemoved` event. Storage variables modified: `incentives`, `whitelistedTokens` (via `_deleteWhitelistedTokenFromList`). Requires the `onlyFactoryVaultManager` (inherited) and `onlyWhitelistedToken` modifiers."
  },
  "RewardVault.updateIncentiveManager": {
    "type": "external",
    "function_name": "updateIncentiveManager(address token, address newManager)",
    "analysis_result": "Allows the factory owner to update the `manager` address for an existing whitelisted incentive token. It takes the `token` address and the `newManager` address. It requires the `token` to be whitelisted and the `newManager` address to be non-zero. It updates the `manager` field in the `incentives` mapping for the given token. Emits the `IncentiveManagerChanged` event, including the old and new manager addresses. Storage variables modified: `incentives[token].manager`. Requires the `onlyFactoryOwner` (inherited) and `onlyWhitelistedToken` modifiers."
  },
  "RewardVault.setMaxIncentiveTokensCount": {
    "type": "external",
    "function_name": "setMaxIncentiveTokensCount(uint8 _maxIncentiveTokensCount)",
    "analysis_result": "Allows the factory owner to set the maximum number of incentive tokens that can be whitelisted. It takes the `_maxIncentiveTokensCount` as a parameter. It requires the new maximum count to be greater than or equal to the current number of whitelisted tokens (`whitelistedTokens.length`). Updates the `maxIncentiveTokensCount` storage variable. Emits the `MaxIncentiveTokensCountUpdated` event. Storage variables modified: `maxIncentiveTokensCount`. Storage variables read: `whitelistedTokens`. Requires the `onlyFactoryOwner` modifier (inherited)."
  },
  "RewardVault.pause": {
    "type": "external",
    "function_name": "pause()",
    "analysis_result": "Pauses the contract, preventing execution of functions protected by the `whenNotPaused` modifier. It calls the inherited `_pause()` function from `PausableUpgradeable`. Requires the `onlyFactoryVaultPauser` modifier (inherited)."
  },
  "RewardVault.unpause": {
    "type": "external",
    "function_name": "unpause()",
    "analysis_result": "Unpauses the contract, allowing execution of functions protected by the `whenNotPaused` modifier. It calls the inherited `_unpause()` function from `PausableUpgradeable`. Requires the `onlyFactoryVaultManager` modifier (inherited)."
  },
  "RewardVault.operator": {
    "type": "external",
    "function_name": "operator(address account)",
    "analysis_result": "A public view function that returns the operator address for a given `account` by querying the `_operators` mapping. Storage variables read: `_operators`. Returns: `address`."
  },
  "RewardVault.getWhitelistedTokensCount": {
    "type": "external",
    "function_name": "getWhitelistedTokensCount()",
    "analysis_result": "A public view function that returns the current number of whitelisted incentive tokens. It returns the length of the `whitelistedTokens` array. Storage variables read: `whitelistedTokens`. Returns: `uint256`."
  },
  "RewardVault.getWhitelistedTokens": {
    "type": "public",
    "function_name": "getWhitelistedTokens() view returns (address[] memory)",
    "analysis_result": "A public view function that returns the array of all whitelisted incentive token addresses (`whitelistedTokens`). Storage variables read: `whitelistedTokens`. Returns: `address[] memory`."
  },
  "RewardVault.getTotalDelegateStaked": {
    "type": "external",
    "function_name": "getTotalDelegateStaked(address account)",
    "analysis_result": "A public view function that returns the total amount of stake delegated by others to a specific `account`. It queries the `_delegateStake` mapping for the `account` and returns the `delegateTotalStaked` field. Storage variables read: `_delegateStake`. Returns: `uint256`."
  },
  "RewardVault.getDelegateStake": {
    "type": "external",
    "function_name": "getDelegateStake(address account, address delegate)",
    "analysis_result": "A public view function that returns the amount of stake delegated by a specific `delegate` to a specific `account`. It queries the `_delegateStake` mapping for the `account` and then looks up the `delegate` in the nested `stakedByDelegate` mapping. Storage variables read: `_delegateStake`. Returns: `uint256`."
  },
  "RewardVault.stake": {
    "type": "external",
    "function_name": "stake(uint256 amount)",
    "analysis_result": "Allows `msg.sender` to stake `amount` of the `stakeToken`. It uses the `nonReentrant` and `whenNotPaused` modifiers to prevent reentrancy and ensure the contract is not paused. It calls the inherited `_stake(msg.sender, amount)` function from `StakingRewards` to handle the staking logic (transferring tokens to the contract, updating total supply, and updating user's account balance). Storage variables modified: `_accountInfo[msg.sender].balance`, `totalSupply` (via `_stake`). Requires the `nonReentrant` and `whenNotPaused` modifiers."
  },
  "RewardVault.delegateStake": {
    "type": "external",
    "function_name": "delegateStake(address account, uint256 amount)",
    "analysis_result": "Allows `msg.sender` (a delegate) to stake `amount` on behalf of another `account`. It requires `msg.sender` not to be the same as `account`. It uses the `nonReentrant` and `whenNotPaused` modifiers. It first calls the inherited `_stake(account, amount)` function to perform the actual staking of tokens for the specified `account`. Then, in an unchecked block, it updates the `_delegateStake` mapping for the `account`: incrementing `delegateTotalStaked` and the amount staked by the specific `msg.sender` delegate (`stakedByDelegate[msg.sender]`). Emits the `DelegateStaked` event. Storage variables modified: `_accountInfo[account].balance`, `totalSupply` (via `_stake`), `_delegateStake[account].delegateTotalStaked`, `_delegateStake[account].stakedByDelegate[msg.sender]`. Requires the `nonReentrant` and `whenNotPaused` modifiers."
  },
  "RewardVault.withdraw": {
    "type": "external",
    "function_name": "withdraw(uint256 amount)",
    "analysis_result": "Allows `msg.sender` to withdraw `amount` of their self-staked tokens. It uses the `nonReentrant` and `checkSelfStakedBalance(msg.sender, amount)` modifiers. The `checkSelfStakedBalance` modifier ensures that the withdrawn `amount` does not exceed the portion of the user's total stake that was not delegated by others. It calls the inherited `_withdraw(msg.sender, amount)` function from `StakingRewards` to handle the withdrawal logic (transferring tokens from the contract, updating total supply, and updating user's account balance). Storage variables modified: `_accountInfo[msg.sender].balance`, `totalSupply` (via `_withdraw`). Storage variables read: `_accountInfo[msg.sender].balance`, `_delegateStake[msg.sender].delegateTotalStaked` (via `checkSelfStakedBalance`). Requires the `nonReentrant` and `checkSelfStakedBalance` modifiers."
  },
  "RewardVault.delegateWithdraw": {
    "type": "external",
    "function_name": "delegateWithdraw(address account, uint256 amount)",
    "analysis_result": "Allows `msg.sender` (a delegate) to withdraw `amount` from the stake they previously delegated to an `account`. It requires `msg.sender` not to be the same as `account`. It uses the `nonReentrant` modifier. It retrieves the amount staked by the delegate (`stakedByDelegate[msg.sender]`) from the `_delegateStake` mapping for the `account`. It checks if this amount is sufficient for the withdrawal, reverting with `InsufficientDelegateStake` if not. In an unchecked block, it decreases `_delegateStake[account].stakedByDelegate[msg.sender]` and `_delegateStake[account].delegateTotalStaked` by the `amount`. Finally, it calls the inherited `_withdraw(account, amount)` function to perform the actual token transfer and update the `account`'s total stake. Emits the `DelegateWithdrawn` event. Storage variables modified: `_delegateStake[account].stakedByDelegate[msg.sender]`, `_delegateStake[account].delegateTotalStaked`, `_accountInfo[account].balance`, `totalSupply` (via `_withdraw`). Requires the `nonReentrant` modifier."
  },
  "RewardVault.getReward": {
    "type": "external",
    "function_name": "getReward(address account, address recipient) returns (uint256)",
    "analysis_result": "Allows an `account` or their designated operator (`msg.sender`) to claim pending BGT rewards. It takes the `account` whose rewards are being claimed and the `recipient` address where the rewards should be sent. It uses the `nonReentrant` and `onlyOperatorOrUser(account)` modifiers. It calls the inherited `_getReward(account, recipient)` function from `StakingRewards` to calculate and transfer the earned rewards to the `recipient`. Returns the amount of reward transferred. Storage variables modified: `userRewardPerTokenPaid[account]`, `rewards[account]` (via `_getReward`). Requires the `nonReentrant` and `onlyOperatorOrUser` modifiers."
  },
  "RewardVault.exit": {
    "type": "external",
    "function_name": "exit(address recipient)",
    "analysis_result": "Allows `msg.sender` to withdraw all their self-staked tokens and claim all pending BGT rewards in a single transaction. It uses the `nonReentrant` modifier. It calculates the user's self-staked amount by subtracting the total delegated stake (`_delegateStake[msg.sender].delegateTotalStaked`) from their total stake (`_accountInfo[msg.sender].balance`). It then calls the inherited `_withdraw(msg.sender, amount)` to withdraw the self-staked amount and the inherited `_getReward(msg.sender, recipient)` to claim rewards and send them to the `recipient`. Storage variables read: `_accountInfo[msg.sender].balance`, `_delegateStake[msg.sender].delegateTotalStaked`. Storage variables modified: `_accountInfo[msg.sender].balance`, `totalSupply`, `userRewardPerTokenPaid[msg.sender]`, `rewards[msg.sender]` (via `_withdraw` and `_getReward`). Requires the `nonReentrant` modifier."
  },
  "RewardVault.setOperator": {
    "type": "external",
    "function_name": "setOperator(address _operator)",
    "analysis_result": "Allows `msg.sender` to set or update their designated operator address. It takes the `_operator` address as a parameter. It updates the `_operators` mapping for `msg.sender`. Emits the `OperatorSet` event, showing the user and their new operator. Storage variables modified: `_operators[msg.sender]`."
  },
  "RewardVault.addIncentive": {
    "type": "external",
    "function_name": "addIncentive(address token, uint256 amount, uint256 incentiveRate)",
    "analysis_result": "Allows the manager of a whitelisted incentive token to add more incentive tokens to the contract and optionally update the `incentiveRate`. It requires the `token` to be whitelisted via the `onlyWhitelistedToken` modifier. It uses the `nonReentrant` modifier. It checks if `msg.sender` is the designated `manager` for the token. It validates that the `amount` is at least the `minIncentiveRate` and that the new `incentiveRate` is at least the `minIncentiveRate` and within `MAX_INCENTIVE_RATE`. It uses `SafeERC20.safeTransferFrom` to pull the `amount` of tokens from the manager's address to the contract. It adds the `amount` to the `incentives[token].amountRemaining`. It updates the `incentiveRate` if the `amountRemaining` *before* adding the new amount was 0, or if the new `incentiveRate` is greater than or equal to the stored rate. If `amountRemainingBefore` is non-zero and the new rate is less than the stored rate, it reverts with `InvalidIncentiveRate`. Emits the `IncentiveAdded` event. Storage variables modified: `incentives[token].amountRemaining`, `incentives[token].incentiveRate`. Storage variables read: `incentives[token]`. Requires the `nonReentrant` and `onlyWhitelistedToken` modifiers."
  },
  "RewardVault.accountIncentives": {
    "type": "external",
    "function_name": "accountIncentives(address token, uint256 amount)",
    "analysis_result": "Allows the manager of a whitelisted incentive token to increase the `amountRemaining` for a token without transferring new tokens into the contract. This might be used if tokens are deposited via a different method. It requires the `token` to be whitelisted via `onlyWhitelistedToken` and uses the `nonReentrant` modifier. It checks if `msg.sender` is the designated `manager`. It validates that the `amount` is at least the `minIncentiveRate`. It checks if the contract's balance of the `token` minus the current `amountRemaining` is sufficient to 'account for' the `amount`, preventing adding more to `amountRemaining` than exists in the contract beyond the previously accounted-for amount. It adds the `amount` to `incentives[token].amountRemaining`. Emits the `IncentiveAdded` event (note: same event as `addIncentive`). Storage variables modified: `incentives[token].amountRemaining`. Storage variables read: `incentives[token]`. External calls: `IERC20(token).balanceOf(address(this))`. Requires the `nonReentrant` and `onlyWhitelistedToken` modifiers."
  },
  "RewardVault._checkSelfStakedBalance": {
    "type": "internal",
    "function_name": "_checkSelfStakedBalance(address account, uint256 amount) view",
    "analysis_result": "An internal helper function used by the `checkSelfStakedBalance` modifier. It calculates the `selfStaked` balance for an `account` by subtracting the total amount delegated *to* that account (`_delegateStake[account].delegateTotalStaked`) from the account's total balance (`_accountInfo[account].balance`) in the `StakingRewards` system. It then checks if the calculated `selfStaked` amount is less than the requested `amount` to be withdrawn. If it is, it reverts with `InsufficientSelfStake`. This ensures users can only withdraw the stake they deposited themselves, not stake delegated to them. Storage variables read: `_accountInfo`, `_delegateStake`."
  },
  "RewardVault._safeTransferRewardToken": {
    "type": "internal",
    "function_name": "_safeTransferRewardToken(address to, uint256 amount) override",
    "analysis_result": "Overrides the internal function from the `StakingRewards` base contract. This function is called by `_getReward` in the base contract when distributing rewards. It performs the actual transfer of the `rewardToken` from the `distributor` address to the `to` address. It uses `rewardToken.safeTransferFrom(distributor, to, amount)`. This requires that the `distributor` contract has previously approved the `RewardVault` contract to spend its `rewardToken` balance. Storage variables read: `distributor`, `rewardToken`. External calls: `rewardToken.safeTransferFrom`."
  },
  "RewardVault._checkRewardSolvency": {
    "type": "internal",
    "function_name": "_checkRewardSolvency() view override",
    "analysis_result": "Overrides the internal function from the `StakingRewards` base contract. This function is called by `_notifyRewardAmount` in the base contract to ensure that the reward amount being added does not exceed the contract's ability to pay it out based on the allowance granted by the `distributor`. It checks if the `undistributedRewards` (which includes the new reward) divided by `PRECISION` (to adjust for decimals) is greater than the `allowance` granted by the `distributor` to this contract for the `rewardToken`. If it is greater, it means the distributor hasn't provided sufficient allowance for the reward announced, and the function reverts with `InsolventReward`. Storage variables read: `undistributedRewards`, `distributor`, `rewardToken`. External calls: `rewardToken.allowance(distributor, address(this))`."
  },
  "RewardVault._processIncentives": {
    "type": "internal",
    "function_name": "_processIncentives(bytes calldata pubkey, uint256 bgtEmitted)",
    "analysis_result": "This internal function is called by `notifyRewardAmount` to process the distribution of whitelisted incentive tokens when BGT is emitted (`bgtEmitted`) for a specific validator (`pubkey`). It determines the validator's operator address using `beaconDepositContract.getOperator(pubkey)`. It gets addresses for `beraChef` and `bgtIncentiveDistributor` from the `distributor` contract. It iterates through the `whitelistedTokens` array. For each token, it calculates the `amount` of incentive to distribute based on `bgtEmitted` and `incentive.incentiveRate` using `FixedPointMathLib.mulDiv`, capped by the `incentive.amountRemaining`. If `amount > 0`, it calculates the `validatorShare` using `beraChef.getValidatorIncentiveTokenShare`. It attempts to transfer the `validatorShare` to the validator's operator using a low-level `token.trySafeTransfer(_operator, validatorShare)`. If successful, it updates `amountRemaining` and emits `IncentivesProcessed`. If unsuccessful, it emits `IncentivesProcessFailed`. If any `amount` remains after the validator share, it attempts to transfer it to the `bgtIncentiveDistributor` for BGT boosters. This involves two low-level calls with a `SAFE_GAS_LIMIT`: first, approving the `bgtIncentiveDistributor` to spend the amount via `IERC20.approve`; second, calling `IBGTIncentiveDistributor.receiveIncentive` on the distributor contract. If the receive call succeeds, it updates `amountRemaining` and emits `BGTBoosterIncentivesProcessed`. If either the approve or receive call fails, it emits `BGTBoosterIncentivesProcessFailed` and attempts to reset the allowance to 0 for USDT compatibility. Finally, it updates `incentive.amountRemaining` in storage for the current token. Storage variables read: `beaconDepositContract`, `distributor`, `whitelistedTokens`, `incentives`. Storage variables modified: `incentives[token].amountRemaining`. External calls: `beaconDepositContract.getOperator`, `IDistributor(distributor).beraChef`, `getBGTIncentiveDistributor`, `beraChef.getValidatorIncentiveTokenShare`, `token.trySafeTransfer` (low-level), `token.call` (low-level for approve), `bgtIncentiveDistributor.call` (low-level for receiveIncentive), `token.call` (low-level for resetting allowance). Events emitted: `IncentivesProcessed`, `IncentivesProcessFailed`, `BGTBoosterIncentivesProcessed`, `BGTBoosterIncentivesProcessFailed`."
  },
  "RewardVault._deleteWhitelistedTokenFromList": {
    "type": "internal",
    "function_name": "_deleteWhitelistedTokenFromList(address token)",
    "analysis_result": "An internal helper function called by `removeIncentiveToken` to remove a specific `token` address from the `whitelistedTokens` dynamic array. It iterates through the array to find the index of the `token`. Once found, it swaps the found element with the last element in the array and then uses `whitelistedTokens.pop()` to remove the last element effectively. This maintains the order of other elements but is an efficient way to remove an element from an array by index. Storage variables modified: `whitelistedTokens`. Storage variables read: `whitelistedTokens`."
  },
  "BlockRewardController.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor for the `BlockRewardController` contract. It is marked with `/// @custom:oz-upgrades-unsafe-allow constructor` and calls `_disableInitializers()`. This pattern is used in OpenZeppelin UUPS upgradeable contracts to prevent the `initialize` function from being called twice on the implementation contract itself, ensuring it can only be called on the proxy."
  },
  "BlockRewardController.initialize": {
    "type": "external",
    "function_name": "initialize(address _bgt, address _distributor, address _beaconDepositContract, address _governance)",
    "analysis_result": "This is the initializer function for the upgradeable contract, called once via the proxy upon deployment. It requires the `initializer` modifier. It initializes the `OwnableUpgradeable` aspect by setting the contract owner to `_governance` using `__Ownable_init(_governance)`. It also initializes the `UUPSUpgradeable` aspect using `__UUPSUpgradeable_init()`. It sets the storage variable `bgt` to the address of the BGT token contract (`_bgt`) and `beaconDepositContract` to the address of the `IBeaconDeposit` contract (`_beaconDepositContract`). It sets the `distributor` address to `_distributor` and emits a `SetDistributor` event. It uses `slither-disable-next-line missing-zero-check` comments for the distributor and beacon deposit addresses, indicating a potential consideration about zero address checks, although the code explicitly checks for `_distributor == address(0)` in `setDistributor`. It relies on the caller providing valid, non-zero addresses for BGT, distributor, and beacon deposit contracts."
  },
  "BlockRewardController._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This is an internal function required by the `UUPSUpgradeable` pattern. It defines who is authorized to perform upgrades. The current implementation simply applies the `onlyOwner` modifier. This means only the contract's owner (set during initialization) can call this function and thus authorize an upgrade to `newImplementation`. It does not access or modify any storage variables directly, but relies on the `owner()` state variable implicitly through the `onlyOwner` modifier."
  },
  "BlockRewardController.onlyDistributor": {
    "type": "modifier",
    "function_name": "onlyDistributor()",
    "analysis_result": "This modifier is used to restrict function access. It checks if the `msg.sender` is equal to the address stored in the `distributor` state variable. If the sender is not the distributor, it reverts the transaction with the custom error `NotDistributor`. It is used to protect functions that should only be callable by the designated distributor contract."
  },
  "BlockRewardController.setBaseRate": {
    "type": "external",
    "function_name": "setBaseRate(uint256 _baseRate)",
    "analysis_result": "This function allows the contract owner to set the `baseRate` storage variable. It takes a `uint256 _baseRate` as input. It first checks if `_baseRate` is greater than the constant `MAX_BASE_RATE`. If it is, the transaction is reverted with the custom error `InvalidBaseRate`. Otherwise, it emits a `BaseRateChanged` event with the old and new values and updates the `baseRate` storage variable to `_baseRate`. This function is restricted to the contract `onlyOwner`."
  },
  "BlockRewardController.setRewardRate": {
    "type": "external",
    "function_name": "setRewardRate(uint256 _rewardRate)",
    "analysis_result": "This function allows the contract owner to set the `rewardRate` storage variable. It takes a `uint256 _rewardRate` as input. It first checks if `_rewardRate` is greater than the constant `MAX_REWARD_RATE`. If it is, the transaction is reverted with the custom error `InvalidRewardRate`. Otherwise, it emits a `RewardRateChanged` event with the old and new values and updates the `rewardRate` storage variable to `_rewardRate`. This function is restricted to the contract `onlyOwner`."
  },
  "BlockRewardController.setMinBoostedRewardRate": {
    "type": "external",
    "function_name": "setMinBoostedRewardRate(uint256 _minBoostedRewardRate)",
    "analysis_result": "This function allows the contract owner to set the `minBoostedRewardRate` storage variable. It takes a `uint256 _minBoostedRewardRate` as input. It first checks if `_minBoostedRewardRate` is greater than the constant `MAX_MIN_BOOSTED_REWARD_RATE`. If it is, the transaction is reverted with the custom error `InvalidMinBoostedRewardRate`. Otherwise, it emits a `MinBoostedRewardRateChanged` event with the old and new values and updates the `minBoostedRewardRate` storage variable to `_minBoostedRewardRate`. This function is restricted to the contract `onlyOwner`."
  },
  "BlockRewardController.setBoostMultiplier": {
    "type": "external",
    "function_name": "setBoostMultiplier(uint256 _boostMultiplier)",
    "analysis_result": "This function allows the contract owner to set the `boostMultiplier` storage variable. It takes a `uint256 _boostMultiplier` as input. It first checks if `_boostMultiplier` is greater than the constant `MAX_BOOST_MULTIPLIER`. If it is, the transaction is reverted with the custom error `InvalidBoostMultiplier`. Otherwise, it emits a `BoostMultiplierChanged` event with the old and new values and updates the `boostMultiplier` storage variable to `_boostMultiplier`. This function is restricted to the contract `onlyOwner`."
  },
  "BlockRewardController.setRewardConvexity": {
    "type": "external",
    "function_name": "setRewardConvexity(uint256 _rewardConvexity)",
    "analysis_result": "This function allows the contract owner to set the `rewardConvexity` storage variable. It takes a `uint256 _rewardConvexity` as input. It first checks if `_rewardConvexity` is zero or greater than the constant `MAX_REWARD_CONVEXITY`. If it is, the transaction is reverted with the custom error `InvalidRewardConvexity`. Otherwise, it emits a `RewardConvexityChanged` event with the old (casted from int256 to uint256 for the event) and new values. It then updates the `rewardConvexity` storage variable, storing the provided `uint256` value as an `int256` to avoid casting during future calculations. This function is restricted to the contract `onlyOwner`."
  },
  "BlockRewardController.setDistributor": {
    "type": "external",
    "function_name": "setDistributor(address _distributor)",
    "analysis_result": "This function allows the contract owner to set the address of the distributor contract. It takes an `address _distributor` as input. It first checks if `_distributor` is the zero address. If it is, the transaction is reverted with the custom error `ZeroAddress`. Otherwise, it emits a `SetDistributor` event with the new address and updates the `distributor` storage variable to `_distributor`. This function is restricted to the contract `onlyOwner`."
  },
  "BlockRewardController.computeReward": {
    "type": "public",
    "function_name": "computeReward(uint256 boostPower, uint256 _rewardRate, uint256 _boostMultiplier, int256 _rewardConvexity)",
    "analysis_result": "This function computes the reward amount based on validator boost power and global reward parameters. It is a `pure` function, meaning it does not read from or write to storage. It takes `boostPower`, `_rewardRate`, `_boostMultiplier`, and `_rewardConvexity` as input parameters. It uses the `FixedPointMathLib` for fixed-point arithmetic operations (specifically `WAD`, `powWad`, `mulWad`, `divWad`). The function implements a specific mathematical formula to calculate the `reward`. It handles the edge case `boostPower == 0` by returning 0 reward. It includes a specific check `if (boostPower == one)` (where `one` is `FixedPointMathLib.WAD`) to avoid approximation errors for the specific case where boost power is exactly 1 WAD. The core logic calculates a coefficient based on the formula involving `_boostMultiplier`, `boostPower` raised to the power of `_rewardConvexity`, and then multiplies this coefficient by `_rewardRate`. It includes a check `if (coeff > _boostMultiplier) coeff = _boostMultiplier;` which is noted in the code comments as potentially necessary due to precision errors in splitting the fixed-point operations. It returns the calculated `reward` (uint256)."
  },
  "BlockRewardController.getMaxBGTPerBlock": {
    "type": "public",
    "function_name": "getMaxBGTPerBlock()",
    "analysis_result": "This function calculates and returns the maximum possible BGT reward that could be processed in a block. It is a `view` function, reading from storage but not modifying it. It calls the internal `computeReward` function with `FixedPointMathLib.WAD` as the `boostPower`, and the contract's current storage variables `rewardRate`, `boostMultiplier`, and `rewardConvexity`. This calculates the maximum possible boosted reward. It then checks if this computed reward is less than the `minBoostedRewardRate` storage variable; if so, it sets the reward to `minBoostedRewardRate`. Finally, it adds the `baseRate` storage variable to this value to get the total maximum potential reward (`amount`) per block and returns it. It uses `rewardRate`, `boostMultiplier`, `rewardConvexity`, `minBoostedRewardRate`, and `baseRate` storage variables."
  },
  "BlockRewardController.processRewards": {
    "type": "external",
    "function_name": "processRewards(bytes calldata pubkey, uint64 nextTimestamp, bool isReady)",
    "analysis_result": "This is the main function for processing block rewards for a specific validator identified by `pubkey`. It is restricted to the contract `onlyDistributor`. It takes `pubkey` (validator's public key), `nextTimestamp`, and `isReady` (boolean indicating if berachef/validator is ready) as input. It reads the `baseRate` storage variable. It initializes a local `reward` variable to 0. If `isReady` is true, it calculates the boosted reward: it calls `bgt.normalizedBoost(pubkey)` to get the validator's boost power, then calls the internal `computeReward` function with this boost power and the contract's stored `rewardRate`, `boostMultiplier`, and `rewardConvexity`. It checks if the calculated `reward` is less than the `minBoostedRewardRate` storage variable and sets `reward` to `minBoostedRewardRate` if necessary. After calculating the reward (either boosted or 0 if not ready), it emits a `BlockRewardProcessed` event with `pubkey`, `nextTimestamp`, `baseRate`, and the calculated `reward`. It then interacts with external contracts: it calls `beaconDepositContract.getOperator(pubkey)` to get the operator address associated with the validator's `pubkey`. The comment states this is guaranteed to return a valid address. If `baseRate` is greater than 0, it calls `bgt.mint(operator, base)` to mint the base reward portion to the validator's operator. If the calculated `reward` (boosted reward) is greater than 0, it calls `bgt.mint(distributor, reward)` to mint the boosted reward portion to the `distributor` contract. It returns the calculated `reward` (uint256). It uses `baseRate`, `rewardRate`, `boostMultiplier`, `rewardConvexity`, `minBoostedRewardRate`, `bgt`, `beaconDepositContract`, and `distributor` storage variables. It calls `bgt.normalizedBoost`, `computeReward`, `beaconDepositContract.getOperator`, and `bgt.mint`."
  },
  "BeraChef.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor for the BeraChef contract. It is marked with `custom:oz-upgrades-unsafe-allow constructor` and calls `_disableInitializers()`. This pattern is specific to OpenZeppelin UUPS upgradeable contracts, preventing the `initialize` function from being called more than once via the constructor itself, ensuring initialization is handled through the `initialize` function called by the proxy."
  },
  "BeraChef.initialize": {
    "type": "external",
    "function_name": "initialize(address _distributor, address _factory, address _governance, address _beaconDepositContract, uint8 _maxNumWeightsPerRewardAllocation)",
    "analysis_result": "This is the initializer function for the upgradeable contract, meant to be called once after deployment via a proxy. It takes addresses for the distributor, factory, governance (owner), beacon deposit contract, and the maximum number of weights allowed per reward allocation. It calls `__Ownable_init(_governance)` to initialize ownership, setting the provided governance address as the contract owner. It also calls `__UUPSUpgradeable_init()`. It sets the storage variables `distributor`, `factory`, and `beaconDepositContract` to the provided addresses, with `slither-disable-next-line missing-zero-check` indicating these are expected to be non-zero. It checks if `_maxNumWeightsPerRewardAllocation` is zero and reverts if it is. Finally, it sets the `maxNumWeightsPerRewardAllocation` storage variable and emits the `MaxNumWeightsPerRewardAllocationSet` event."
  },
  "BeraChef._authorizeUpgrade": {
    "type": "internal override",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This is an internal function required by the `UUPSUpgradeable` standard. It is called before an upgrade happens to determine if the caller is authorized. In this implementation, it simply calls the `onlyOwner` modifier, which checks if `msg.sender` is the current owner of the contract (set during initialization). This restricts the ability to upgrade the contract to only the owner."
  },
  "BeraChef.onlyDistributor": {
    "type": "modifier",
    "function_name": "onlyDistributor()",
    "analysis_result": "This modifier checks if the caller (`msg.sender`) is equal to the address stored in the `distributor` storage variable. If they are not equal, it reverts the transaction with `NotDistributor.selector.revertWith()`. This modifier is used to restrict access to certain functions to only the designated distributor contract."
  },
  "BeraChef.onlyOperator": {
    "type": "modifier",
    "function_name": "onlyOperator(bytes calldata valPubkey)",
    "analysis_result": "This modifier checks if the caller (`msg.sender`) is the operator address associated with a given validator public key (`valPubkey`). It calls the `beaconDepositContract`'s `getOperator(valPubkey)` function to retrieve the operator address for the validator. If `msg.sender` is not equal to the retrieved operator address, it reverts the transaction with `NotOperator.selector.revertWith()`. This modifier is used to restrict access to certain functions to only the designated operator of a specific validator."
  },
  "BeraChef.setMaxNumWeightsPerRewardAllocation": {
    "type": "external",
    "function_name": "setMaxNumWeightsPerRewardAllocation(uint8 _maxNumWeightsPerRewardAllocation)",
    "analysis_result": "This function allows the contract owner to set the maximum number of weight entries allowed in a single reward allocation. It uses the `onlyOwner` modifier. It checks if the provided `_maxNumWeightsPerRewardAllocation` is zero and reverts if it is. It then checks if the new maximum is less than the current number of weights in the `defaultRewardAllocation`. If it is, it means the current default allocation would become invalid, so it reverts with `InvalidateDefaultRewardAllocation.selector.revertWith()`. If the checks pass, it updates the `maxNumWeightsPerRewardAllocation` storage variable and emits the `MaxNumWeightsPerRewardAllocationSet` event."
  },
  "BeraChef.setMaxWeightPerVault": {
    "type": "external",
    "function_name": "setMaxWeightPerVault(uint96 _maxWeightPerVault)",
    "analysis_result": "This function allows the contract owner to set the maximum weight a single vault can have within a reward allocation. It uses the `onlyOwner` modifier. It checks if the provided `_maxWeightPerVault` is zero or greater than `ONE_HUNDRED_PERCENT`. If either condition is true, it reverts with `InvalidMaxWeightPerVault.selector.revertWith()`. It updates the `maxWeightPerVault` storage variable. It then calls the internal function `_checkIfStillValid(defaultRewardAllocation.weights)` to verify if the current `defaultRewardAllocation` remains valid under the new `maxWeightPerVault`. If it does not, it reverts with `InvalidateDefaultRewardAllocation.selector.revertWith()`. Finally, it emits the `MaxWeightPerVaultSet` event."
  },
  "BeraChef.setRewardAllocationBlockDelay": {
    "type": "external",
    "function_name": "setRewardAllocationBlockDelay(uint64 _rewardAllocationBlockDelay)",
    "analysis_result": "This function allows the contract owner to set the required block delay before a queued reward allocation can become active. It uses the `onlyOwner` modifier. It checks if the provided `_rewardAllocationBlockDelay` is greater than `MAX_REWARD_ALLOCATION_BLOCK_DELAY`. If it is, it reverts with `RewardAllocationBlockDelayTooLarge.selector.revertWith()`. If the check passes, it updates the `rewardAllocationBlockDelay` storage variable and emits the `RewardAllocationBlockDelaySet` event."
  },
  "BeraChef.setVaultWhitelistedStatus": {
    "type": "external",
    "function_name": "setVaultWhitelistedStatus(address receiver, bool isWhitelisted, string memory metadata)",
    "analysis_result": "This function allows the contract owner to whitelist or unwhitelist a specific vault address. It uses the `onlyOwner` modifier. It first checks if the provided `receiver` address is a valid vault registered with the factory. It does this by calling `RewardVault(receiver).stakeToken()` to get the associated stake token and then calling `IRewardVaultFactory(factory).getVault(stakeToken)` to see if the factory returns the same `receiver` address for that token. If not, it reverts with `NotFactoryVault.selector.revertWith()`. If the receiver is a valid factory vault, it updates the `isWhitelistedVault` mapping for the `receiver` address with the provided `isWhitelisted` status. If `isWhitelisted` is set to `false` (unwhitelisting), it calls `_checkIfStillValid(defaultRewardAllocation.weights)` to ensure the default allocation remains valid. If it becomes invalid, it reverts with `InvalidateDefaultRewardAllocation.selector.revertWith()`. Finally, it emits the `VaultWhitelistedStatusUpdated` event including the metadata."
  },
  "BeraChef.updateWhitelistedVaultMetadata": {
    "type": "external",
    "function_name": "updateWhitelistedVaultMetadata(address vault, string memory metadata)",
    "analysis_result": "This function allows the contract owner to update the metadata associated with a whitelisted vault. It uses the `onlyOwner` modifier. It first checks if the provided `vault` address is currently whitelisted by looking up `isWhitelistedVault[vault]`. If it is not whitelisted, it reverts with `NotWhitelistedVault.selector.revertWith()`. If it is whitelisted, it emits the `WhitelistedVaultMetadataUpdated` event with the vault address and the new metadata."
  },
  "BeraChef.setDefaultRewardAllocation": {
    "type": "external",
    "function_name": "setDefaultRewardAllocation(RewardAllocation calldata ra)",
    "analysis_result": "This function allows the contract owner to set the default reward allocation that is used when a validator does not have a valid active custom allocation. It uses the `onlyOwner` modifier. It takes a `RewardAllocation` struct (`ra`) as input and calls the internal function `_validateWeights(ra.weights)` to ensure the provided weights are valid (total 100%, receivers are whitelisted, within max weights and max weight per vault). If validation passes, it updates the `defaultRewardAllocation` storage variable and emits the `SetDefaultRewardAllocation` event."
  },
  "BeraChef.setCommissionChangeDelay": {
    "type": "external",
    "function_name": "setCommissionChangeDelay(uint64 _commissionChangeDelay)",
    "analysis_result": "This function allows the contract owner to set the required block delay before a queued commission rate change can become active. It uses the `onlyOwner` modifier. It checks if the provided `_commissionChangeDelay` is zero or greater than `MAX_COMMISSION_CHANGE_DELAY`. If either is true, it reverts with `InvalidCommissionChangeDelay.selector.revertWith()`. If the check passes, it updates the `commissionChangeDelay` storage variable and emits the `CommissionChangeDelaySet` event."
  },
  "BeraChef.queueNewRewardAllocation": {
    "type": "external",
    "function_name": "queueNewRewardAllocation(bytes calldata valPubkey, uint64 startBlock, Weight[] calldata weights)",
    "analysis_result": "This function allows a validator's operator to queue a new custom reward allocation for their validator. It uses the `onlyOperator(valPubkey)` modifier to ensure the caller is the registered operator for the given validator public key. It checks if the provided `startBlock` is in the future and adheres to the minimum `rewardAllocationBlockDelay`. If `startBlock` is not greater than `block.number + rewardAllocationBlockDelay`, it reverts with `InvalidStartBlock.selector.revertWith()`. It then checks if there is already a queued reward allocation for this validator by checking `queuedRewardAllocations[valPubkey].startBlock`. If `startBlock` is greater than 0, it means one is already queued, and it reverts with `RewardAllocationAlreadyQueued.selector.revertWith()`. It calls the internal function `_validateWeights(weights)` to validate the provided weights. If validation passes, it stores the `startBlock` and copies the provided `weights` into the `queuedRewardAllocations` mapping for the given `valPubkey`. Finally, it emits the `QueueRewardAllocation` event."
  },
  "BeraChef.queueValCommission": {
    "type": "external",
    "function_name": "queueValCommission(bytes calldata valPubkey, uint96 commissionRate)",
    "analysis_result": "This function allows a validator's operator to queue a change to their validator's commission rate on incentive tokens. It uses the `onlyOperator(valPubkey)` modifier. It checks if the provided `commissionRate` is greater than `ONE_HUNDRED_PERCENT`. If it is, it reverts with `InvalidCommissionValue.selector.revertWith()`. It then checks if there is already a queued commission change for this validator by checking `valQueuedCommission[valPubkey].blockNumberLast`. If `blockNumberLast` is greater than 0, it means one is already queued, and it reverts with `CommissionChangeAlreadyQueued.selector.revertWith()`. If checks pass, it stores the current `block.number` and the new `commissionRate` in the `valQueuedCommission` mapping for the given `valPubkey`. Finally, it emits the `QueuedValCommission` event."
  },
  "BeraChef.activateQueuedValCommission": {
    "type": "external",
    "function_name": "activateQueuedValCommission(bytes calldata valPubkey)",
    "analysis_result": "This function allows anyone to activate a queued commission rate change for a validator, provided the required block delay has passed. It retrieves the queued commission change information (`blockNumberLast`, `commissionRate`) from the `valQueuedCommission` mapping for the given `valPubkey`. It calculates the activation block number by adding `commissionChangeDelay` to `blockNumberLast`. It checks if there was a queued change (`blockNumberLast == 0`) or if the current `block.number` is less than the activation block. If either is true, it reverts with `CommissionNotQueuedOrDelayNotPassed.selector.revertWith()`. If the delay has passed, it retrieves the old commission rate by calling the internal function `_getOperatorCommission(valPubkey)`. It then updates the `valCommission` mapping for the `valPubkey` with a new `CommissionRate` struct containing the calculated `activationBlock` and the queued `commissionRate`. Finally, it emits the `ValCommissionSet` event with the validator pubkey, old commission, and new commission, and deletes the entry from the `valQueuedCommission` mapping."
  },
  "BeraChef.activateReadyQueuedRewardAllocation": {
    "type": "external",
    "function_name": "activateReadyQueuedRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This function is intended to be called by the distributor to activate a queued reward allocation for a validator once its start block has been reached. It uses the `onlyDistributor` modifier. It first calls the public view function `isQueuedRewardAllocationReady(valPubkey, block.number)` to check if a queued allocation exists and is ready for activation. If it's not ready, the function simply returns without doing anything. If it is ready, it retrieves the queued reward allocation (`qra`) from the `queuedRewardAllocations` mapping. It then copies `qra` into the `activeRewardAllocations` mapping for the same `valPubkey`. Finally, it emits the `ActivateRewardAllocation` event and deletes the entry from the `queuedRewardAllocations` mapping."
  },
  "BeraChef.getActiveRewardAllocation": {
    "type": "external view",
    "function_name": "getActiveRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This view function returns the currently active reward allocation for a given validator public key. It first attempts to retrieve the reward allocation (`ara`) from the `activeRewardAllocations` mapping for the `valPubkey`. It then checks if this retrieved allocation is valid by verifying if its `startBlock` is greater than 0 (meaning it was explicitly set) and if it passes the internal `_checkIfStillValid(ara.weights)` check (ensuring weights are within limits and vaults are still whitelisted). If both conditions are true, it returns the `ara`. Otherwise (if no active allocation is set or the active one is no longer valid), it returns the `defaultRewardAllocation`."
  },
  "BeraChef.getQueuedRewardAllocation": {
    "type": "external view",
    "function_name": "getQueuedRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This view function returns the queued reward allocation for a given validator public key. It simply retrieves and returns the `RewardAllocation` struct stored in the `queuedRewardAllocations` mapping for the specified `valPubkey`. If no allocation is queued, it will return a struct with default values (startBlock 0, empty weights array)."
  },
  "BeraChef.getSetActiveRewardAllocation": {
    "type": "external view",
    "function_name": "getSetActiveRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This view function returns the reward allocation explicitly *set* as active for a given validator public key, without checking its validity against current contract state (like whitelisted vaults or max weights). It directly retrieves and returns the `RewardAllocation` struct stored in the `activeRewardAllocations` mapping for the specified `valPubkey`. This differs from `getActiveRewardAllocation` which checks validity and falls back to the default."
  },
  "BeraChef.getDefaultRewardAllocation": {
    "type": "external view",
    "function_name": "getDefaultRewardAllocation()",
    "analysis_result": "This view function returns the current default reward allocation set by the contract owner. It directly retrieves and returns the `defaultRewardAllocation` storage variable."
  },
  "BeraChef.isQueuedRewardAllocationReady": {
    "type": "public view",
    "function_name": "isQueuedRewardAllocationReady(bytes calldata valPubkey, uint256 blockNumber)",
    "analysis_result": "This view function checks if a queued reward allocation for a given validator is ready to be activated at a specific block number. It takes the validator public key (`valPubkey`) and a target `blockNumber` as input. It retrieves the `startBlock` of the queued allocation from the `queuedRewardAllocations` mapping. It returns `true` if a queued allocation exists (`startBlock != 0`) and the target `blockNumber` is greater than or equal to the `startBlock`. Otherwise, it returns `false`."
  },
  "BeraChef.isReady": {
    "type": "external view",
    "function_name": "isReady()",
    "analysis_result": "This view function indicates whether the BeraChef contract is considered 'ready' for operation. It returns `true` if the `defaultRewardAllocation` has been set (checked by verifying if its `weights` array has a length greater than 0). Otherwise, it returns `false`. This serves as a simple status check."
  },
  "BeraChef.getValCommissionOnIncentiveTokens": {
    "type": "external view",
    "function_name": "getValCommissionOnIncentiveTokens(bytes calldata valPubkey)",
    "analysis_result": "This view function returns the currently active commission rate for a validator on incentive tokens. It takes the validator public key (`valPubkey`) as input and calls the internal view function `_getOperatorCommission(valPubkey)` which handles retrieving the commission rate or returning the default rate if none is explicitly set."
  },
  "BeraChef.getValQueuedCommissionOnIncentiveTokens": {
    "type": "external view",
    "function_name": "getValQueuedCommissionOnIncentiveTokens(bytes calldata valPubkey)",
    "analysis_result": "This view function returns the queued commission rate change information for a validator, if any. It takes the validator public key (`valPubkey`) as input. It retrieves and returns the `QueuedCommissionRateChange` struct stored in the `valQueuedCommission` mapping for the specified `valPubkey`. If no change is queued, it will return a struct with default values (blockNumberLast 0, commissionRate 0)."
  },
  "BeraChef.getValidatorIncentiveTokenShare": {
    "type": "external view",
    "function_name": "getValidatorIncentiveTokenShare(bytes calldata valPubkey, uint256 incentiveTokenAmount)",
    "analysis_result": "This view function calculates the portion of a given incentive token amount that corresponds to a validator's commission. It takes the validator public key (`valPubkey`) and the total `incentiveTokenAmount` as input. It first calls the internal view function `_getOperatorCommission(valPubkey)` to get the validator's active commission rate. It then calculates the operator's share by multiplying the `incentiveTokenAmount` by the commission rate and dividing by `ONE_HUNDRED_PERCENT`. It returns the calculated operator's share as a `uint256`."
  },
  "BeraChef._validateWeights": {
    "type": "internal view",
    "function_name": "_validateWeights(Weight[] calldata weights)",
    "analysis_result": "This internal view function validates an array of `Weight` structs intended for a reward allocation. It takes the `weights` array as input. It first checks if the number of weights (`weights.length`) exceeds `maxNumWeightsPerRewardAllocation`. If it does, it reverts with `TooManyWeights.selector.revertWith()`. It then iterates through the weights. For each weight, it checks if `percentageNumerator` is zero or greater than `maxWeightPerVault`. If either is true, it reverts with `InvalidWeight.selector.revertWith()`. It also checks if the `receiver` address for the weight is whitelisted using the `isWhitelistedVault` mapping. If any receiver is not whitelisted, it reverts with `NotWhitelistedVault.selector.revertWith()`. During the iteration, it sums up the `percentageNumerator` values into a `totalWeight`. After iterating through all weights, it checks if `totalWeight` equals `ONE_HUNDRED_PERCENT`. If not, it reverts with `InvalidRewardAllocationWeights.selector.revertWith()`. This function is used by `setDefaultRewardAllocation` and `queueNewRewardAllocation` before setting or queuing an allocation."
  },
  "BeraChef._checkIfStillValid": {
    "type": "internal view",
    "function_name": "_checkIfStillValid(Weight[] memory weights)",
    "analysis_result": "This internal view function checks if the weights of a reward allocation are still valid based on the current contract state (`maxNumWeightsPerRewardAllocation`, `maxWeightPerVault`, `isWhitelistedVault`). It is used to validate existing reward allocations (like the active or default ones). It takes a `weights` array (memory) as input. It first checks if the length of the `weights` array is greater than the current `maxNumWeightsPerRewardAllocation`. If so, it returns `false`. It then iterates through the weights. For each weight, it checks if its `percentageNumerator` is greater than the current `maxWeightPerVault` or if its `receiver` address is not whitelisted. If either condition is met for any weight, it immediately returns `false`. If the loop completes without finding any invalid weights, it returns `true`. This function is used by `getActiveRewardAllocation`, `setMaxWeightPerVault`, and `setVaultWhitelistedStatus`."
  },
  "BeraChef._getOperatorCommission": {
    "type": "internal view",
    "function_name": "_getOperatorCommission(bytes calldata valPubkey)",
    "analysis_result": "This internal view function retrieves the active commission rate for a validator. It takes the validator public key (`valPubkey`) as input. It looks up the `CommissionRate` struct in the `valCommission` mapping for the `valPubkey`. If the `activationBlock` in the retrieved struct is 0, it indicates that no custom commission rate has ever been set or activated for this validator, so it returns the constant `DEFAULT_COMMISSION_RATE`. Otherwise, it returns the `commissionRate` stored in the struct. This function is used by `activateQueuedValCommission`, `getValCommissionOnIncentiveTokens`, and `getValidatorIncentiveTokenShare`."
  },
  "BGTIncentiveDistributor.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "Purpose: To disable initializers for upgradeability. Variables Used: None directly. Calls: _disableInitializers(). Logic: Standard practice for OpenZeppelin UUPS upgradeable contracts to prevent 'initialize' from being called during deployment."
  },
  "BGTIncentiveDistributor.initialize": {
    "type": "external",
    "function_name": "initialize(address _governance)",
    "analysis_result": "Purpose: Initializes the contract after deployment. Sets up AccessControl, Pausable, ReentrancyGuard, and UUPS. Grants the DEFAULT_ADMIN_ROLE to _governance and sets the initial rewardClaimDelay. Variables Used: rewardClaimDelay. Storage Modified: AccessControl roles, Pausable state, ReentrancyGuard state, UUPS state, rewardClaimDelay. Calls: __AccessControl_init(), __Pausable_init(), __ReentrancyGuard_init(), __UUPSUpgradeable_init(), _grantRole(DEFAULT_ADMIN_ROLE, _governance), _setRewardClaimDelay(MAX_REWARD_CLAIM_DELAY). Logic: Basic setup and access control configuration for the upgradeable contract. Requires _governance not to be the zero address. Modifiers: initializer."
  },
  "BGTIncentiveDistributor._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "Purpose: Internal hook for OpenZeppelin UUPS upgradeability. Controls who can authorize contract upgrades. Variables Used: None directly. Calls: None directly, part of UUPS framework. Logic: Allows upgrade only if the caller has the DEFAULT_ADMIN_ROLE. Modifiers: override, onlyRole(DEFAULT_ADMIN_ROLE)."
  },
  "BGTIncentiveDistributor.setRewardClaimDelay": {
    "type": "external",
    "function_name": "setRewardClaimDelay(uint64 _delay)",
    "analysis_result": "Purpose: Allows the admin to set the delay period after reward metadata update before rewards are claimable. Variables Used: rewardClaimDelay. Storage Modified: rewardClaimDelay (via _setRewardClaimDelay). Calls: _setRewardClaimDelay(_delay). Logic: Forwards the call to the internal helper function _setRewardClaimDelay. Modifiers: onlyRole(DEFAULT_ADMIN_ROLE)."
  },
  "BGTIncentiveDistributor.updateRewardsMetadata": {
    "type": "external",
    "function_name": "updateRewardsMetadata(Distribution[] calldata _distributions)",
    "analysis_result": "Purpose: Allows a manager to update the Merkle roots and metadata for reward distributions. Variables Used: rewards, rewardClaimDelay. Storage Modified: rewards. Calls: InvalidDistribution.selector.revertWith(), InvalidToken.selector.revertWith(). Emits: RewardMetadataUpdated. Logic: Iterates through distributions, updates merkleRoot, proof, activeAt (based on current time + rewardClaimDelay), and pubkey in the 'rewards' mapping. Sets the 'token' on the first update for an identifier and checks for consistency on subsequent updates. Reverts if input array is empty or token changes for an identifier. Modifiers: onlyRole(MANAGER_ROLE)."
  },
  "BGTIncentiveDistributor.setPauseState": {
    "type": "external",
    "function_name": "setPauseState(bool state)",
    "analysis_result": "Purpose: Allows a pauser to pause or unpause the contract, affecting functions with the 'whenNotPaused' modifier. Variables Used: Pausing state (managed by PausableUpgradeable). Storage Modified: Pausing state. Calls: _pause() or _unpause(). Logic: Calls the appropriate OpenZeppelin internal function based on the desired 'state'. Modifiers: onlyRole(PAUSER_ROLE)."
  },
  "BGTIncentiveDistributor.receiveIncentive": {
    "type": "external",
    "function_name": "receiveIncentive(bytes calldata pubkey, address token, uint256 _amount)",
    "analysis_result": "Purpose: Allows an external caller (e.g., a reward vault) to send incentive tokens to this contract and register them against a specific validator pubkey and token address. Variables Used: incentiveTokensPerValidator. Storage Modified: incentiveTokensPerValidator. Calls: IERC20(token).safeTransferFrom(msg.sender, address(this), _amount). Emits: IncentiveReceived. Logic: Transfers tokens from the caller to the contract and updates the internal tracking of tokens available per validator pubkey and token type. Note: Based on code, anyone can call this."
  },
  "BGTIncentiveDistributor.claim": {
    "type": "external",
    "function_name": "claim(Claim[] calldata _claims)",
    "analysis_result": "Purpose: Allows a user to claim rewards for one or more distributions using Merkle proofs. Variables Used: None directly, but calls _claim. Calls: _claim(...) for each item, InvalidArray.selector.revertWith(). Logic: Iterates through the provided claims array and calls the internal _claim function for each individual claim. Reverts if input array is empty. Modifiers: nonReentrant, whenNotPaused."
  },
  "BGTIncentiveDistributor._claim": {
    "type": "private",
    "function_name": "_claim(bytes32 _identifier, address _account, uint256 _amount, bytes32[] calldata _merkleProof)",
    "analysis_result": "Purpose: Internal function to process a single reward claim. Verifies Merkle proof, updates claimed amount, checks token balance, and transfers tokens. Variables Used: rewards, claimed, incentiveTokensPerValidator. Storage Modified: claimed, incentiveTokensPerValidator. Calls: MerkleProof.verifyCalldata(...), IERC20(token).safeTransfer(...), InvalidMerkleRoot.selector.revertWith(), RewardInactive.selector.revertWith(), InvalidProof.selector.revertWith(), InsufficientIncentiveTokens.selector.revertWith(). Emits: RewardClaimed. Logic: Retrieves reward metadata, checks if active. Calculates the *total* claimed amount (_claimed + _amount) and verifies the Merkle proof against this total. Updates the 'claimed' mapping to this total. Checks if sufficient tokens are available for the associated validator and token type. Decrements validator's token balance and transfers tokens to the user. Reverts if metadata doesn't exist, reward is inactive, proof is invalid, or insufficient tokens are held for the validator. Modifiers: None (private helper)."
  },
  "BGTIncentiveDistributor._setRewardClaimDelay": {
    "type": "internal",
    "function_name": "_setRewardClaimDelay(uint64 _delay)",
    "analysis_result": "Purpose: Internal function to set the reward claim delay. Variables Used: rewardClaimDelay, MAX_REWARD_CLAIM_DELAY. Storage Modified: rewardClaimDelay. Calls: InvalidRewardClaimDelay.selector.revertWith(). Emits: RewardClaimDelaySet. Logic: Sets the 'rewardClaimDelay' state variable after checking it does not exceed 'MAX_REWARD_CLAIM_DELAY'. Modifiers: None (internal helper)."
  },
  "Distributor.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor for the upgradeable contract. It calls _disableInitializers() to prevent the `initialize` function from being called outside of the proxy deployment process. It uses no storage variables directly and does not call other functions within this contract, only the inherited _disableInitializers()."
  },
  "Distributor.initialize": {
    "type": "external",
    "function_name": "initialize(address _berachef, address _bgt, address _blockRewardController, address _governance, uint64 _zeroValidatorPubkeyGIndex, uint64 _proposerIndexGIndex)",
    "analysis_result": "This function serves as the initializer for the upgradeable contract, intended to be called once immediately after deployment via a proxy. It initializes core components: `AccessControl`, `ReentrancyGuard`, and `UUPSUpgradeable` using their respective `__init` functions. It sets critical storage variables: `beraChef`, `bgt`, and `blockRewardController` based on provided addresses. It grants the `DEFAULT_ADMIN_ROLE` to the specified `_governance` address using `_grantRole`. Finally, it sets the `zeroValidatorPubkeyGIndex` and `proposerIndexGIndex` required for beacon chain verification by calling the inherited `setZeroValidatorPubkeyGIndex` and `setProposerIndexGIndex` functions from `BeaconRootsHelper`. It depends on `AccessControlUpgradeable`, `ReentrancyGuardUpgradeable`, `UUPSUpgradeable`, and `BeaconRootsHelper` for initialization and setting parameters."
  },
  "Distributor._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This internal function is required by the `UUPSUpgradeable` pattern. It defines the authorization logic for contract upgrades. It uses the `onlyRole(DEFAULT_ADMIN_ROLE)` modifier to restrict upgrade calls to addresses holding the `DEFAULT_ADMIN_ROLE`. It checks the caller's role using the AccessControl's internal state (_roles mapping) and does not directly modify any storage variables within this contract, only performing a permission check."
  },
  "Distributor.setZeroValidatorPubkeyGIndex": {
    "type": "public",
    "function_name": "setZeroValidatorPubkeyGIndex(uint64 _zeroValidatorPubkeyGIndex)",
    "analysis_result": "This function allows updating the GIndex used by `BeaconRootsHelper` to locate a validator's public key in the beacon state tree. This might be necessary after beacon chain hard forks that change the state structure. It uses the `onlyRole(MANAGER_ROLE)` modifier to restrict access to addresses holding the `MANAGER_ROLE`. It calls the inherited `setZeroValidatorPubkeyGIndex` function from `BeaconRootsHelper`, which modifies the `zeroValidatorPubkeyGIndex` storage variable within the inherited contract state."
  },
  "Distributor.setProposerIndexGIndex": {
    "type": "public",
    "function_name": "setProposerIndexGIndex(uint64 _proposerIndexGIndex)",
    "analysis_result": "This function allows updating the GIndex used by `BeaconRootsHelper` to locate the proposer index in the beacon state tree. This might be necessary after beacon chain hard forks. It uses the `onlyRole(MANAGER_ROLE)` modifier to restrict access to addresses holding the `MANAGER_ROLE`. It calls the inherited `setProposerIndexGIndex` function from `BeaconRootsHelper`, which modifies the `proposerIndexGIndex` storage variable within the inherited contract state."
  },
  "Distributor.distributeFor": {
    "type": "external",
    "function_name": "distributeFor(uint64 nextTimestamp, uint64 proposerIndex, bytes calldata pubkey, bytes32[] calldata proposerIndexProof, bytes32[] calldata pubkeyProof)",
    "analysis_result": "This is the main entry point for initiating reward distribution for a block's proposer. It uses the `nonReentrant` modifier to prevent reentrancy attacks. It first calls `_processTimestampInBuffer(nextTimestamp)` (inherited from BeaconRootsHelper) to ensure the timestamp is processed sequentially and isn't a duplicate, potentially modifying BeaconRootsHelper's internal timestamp buffer storage. It then performs two critical verification steps using methods from BeaconRootsHelper: `_verifyProposerIndexInBeaconBlock` to check if the provided `proposerIndex` is correct for the block root derived from `nextTimestamp`, and `_verifyValidatorPubkeyInBeaconBlock` to verify the `pubkey` at the specified `proposerIndex`. If all verifications pass, it calls the internal `_distributeFor(pubkey, nextTimestamp)` function to handle the actual reward calculation and distribution logic. It relies heavily on the verification logic provided by `BeaconRootsHelper`."
  },
  "Distributor._distributeFor": {
    "type": "internal",
    "function_name": "_distributeFor(bytes calldata pubkey, uint64 nextTimestamp)",
    "analysis_result": "This internal function handles the core logic of calculating and distributing rewards for a specific validator (identified by `pubkey`) for a block associated with `nextTimestamp`. It first calls `blockRewardController.processRewards(pubkey, nextTimestamp, beraChef.isReady())` using the stored `blockRewardController` and `beraChef` interfaces to get the reward amount for this block. If `rewardRate` is 0, distribution is skipped. It then calls `beraChef.activateReadyQueuedRewardAllocation(pubkey)` on the stored `beraChef` to potentially activate a pending reward allocation. It retrieves the active reward allocation structure for the validator via `beraChef.getActiveRewardAllocation(pubkey)`, which may return a default allocation. It iterates through the `weights` array within the retrieved `RewardAllocation`. For each weight (receiver and percentage): it calculates the `rewardAmount` using `FixedPointMathLib.fullMulDiv` based on the `rewardRate` and the receiver's percentage weight (adjusted for the last receiver to use the remainder). It then calls `bgt.safeIncreaseAllowance(receiver, rewardAmount)` on the stored `bgt` token contract to approve the receiver (expected to be a RewardVault) to pull the tokens. Finally, it notifies the receiver's contract (cast to `IRewardVault`) by calling `notifyRewardAmount(pubkey, rewardAmount)`. It tracks `totalRewardDistributed` to correctly calculate the last receiver's share. It emits the `Distributed` event for each distribution. This function reads `beraChef`, `blockRewardController`, and `bgt` storage variables but does not modify storage within the Distributor contract itself (except indirectly via external calls like allowance modification). It depends on the `IBeraChef`, `IBlockRewardController`, `IRewardVault` interfaces, `FixedPointMathLib`, and the token contract's allowance mechanism."
  },
  "RewardVaultFactory.VAULT_MANAGER_ROLE": {
    "type": "public",
    "function_name": "VAULT_MANAGER_ROLE()",
    "analysis_result": "This is a public view function automatically generated for the public state variable `VAULT_MANAGER_ROLE`. It returns the bytes32 value representing the vault manager role. It does not modify any storage variables and serves as a constant getter."
  },
  "RewardVaultFactory.VAULT_PAUSER_ROLE": {
    "type": "public",
    "function_name": "VAULT_PAUSER_ROLE()",
    "analysis_result": "This is a public view function automatically generated for the public state variable `VAULT_PAUSER_ROLE`. It returns the bytes32 value representing the vault pauser role. It does not modify any storage variables and serves as a constant getter."
  },
  "RewardVaultFactory.beacon": {
    "type": "public",
    "function_name": "beacon()",
    "analysis_result": "This is a public view function automatically generated for the public state variable `beacon`. It returns the address of the UpgradeableBeacon contract used for cloning RewardVault implementations. It does not modify any storage variables and serves as a state variable getter."
  },
  "RewardVaultFactory.bgt": {
    "type": "public",
    "function_name": "bgt()",
    "analysis_result": "This is a public view function automatically generated for the public state variable `bgt`. It returns the address of the BGT token. It does not modify any storage variables and serves as a state variable getter."
  },
  "RewardVaultFactory.distributor": {
    "type": "public",
    "function_name": "distributor()",
    "analysis_result": "This is a public view function automatically generated for the public state variable `distributor`. It returns the address of the main distributor contract. It does not modify any storage variables and serves as a state variable getter."
  },
  "RewardVaultFactory.beaconDepositContract": {
    "type": "public",
    "function_name": "beaconDepositContract()",
    "analysis_result": "This is a public view function automatically generated for the public state variable `beaconDepositContract`. It returns the address of the BeaconDeposit contract. It does not modify any storage variables and serves as a state variable getter."
  },
  "RewardVaultFactory.getVault": {
    "type": "public",
    "function_name": "getVault(address stakingToken)",
    "analysis_result": "This is a public view function automatically generated for the public mapping state variable `getVault`. It takes a `stakingToken` address as input and returns the address of the associated RewardVault contract if one has been created, otherwise returns address(0). It reads from the `getVault` mapping. It does not modify any storage variables."
  },
  "RewardVaultFactory.allVaults": {
    "type": "public",
    "function_name": "allVaults(uint256)",
    "analysis_result": "This is a public view function automatically generated for the public array state variable `allVaults`. It takes an index as input and returns the address of the RewardVault contract stored at that index in the array. It reads from the `allVaults` array. It does not modify any storage variables."
  },
  "RewardVaultFactory.bgtIncentiveDistributor": {
    "type": "public",
    "function_name": "bgtIncentiveDistributor()",
    "analysis_result": "This is a public view function automatically generated for the public state variable `bgtIncentiveDistributor`. It returns the address of the BGTIncentiveDistributor contract. It does not modify any storage variables and serves as a state variable getter."
  },
  "RewardVaultFactory.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "This is the contract constructor. It is called only once upon deployment. Its purpose is to disable the initializer function for upgradeable contracts using the `_disableInitializers()` function from OpenZeppelin's UUPSUpgradeable. This prevents the `initialize` function from being called again after the initial setup, ensuring proper upgradeability patterns are followed. It does not take any arguments and does not interact with other contract functions or state variables other than calling `_disableInitializers()`."
  },
  "RewardVaultFactory.initialize": {
    "type": "external",
    "function_name": "initialize(address _bgt, address _distributor, address _beaconDepositContract, address _governance, address _vaultImpl)",
    "analysis_result": "This is the initializer function for the upgradeable proxy contract. It can only be called once. It initializes the AccessControl and UUPSUpgradeable components using `__AccessControl_init()` and `__UUPSUpgradeable_init()`. It grants the `DEFAULT_ADMIN_ROLE` to the provided `_governance` address. It sets the admin role for the `VAULT_PAUSER_ROLE` to `VAULT_MANAGER_ROLE`, allowing Vault Managers to manage Pausers. It assigns the provided addresses for `_bgt`, `_distributor`, and `_beaconDepositContract` to the respective state variables (`bgt`, `distributor`, `beaconDepositContract`). It uses Solady's `UpgradeableBeacon` to deploy a new Beacon contract, setting the provided `_governance` as its owner and `_vaultImpl` as the implementation address, and stores the beacon's address in the `beacon` state variable. It requires non-zero addresses for the input parameters implicitly by checking against `address(0)` later in `setBGTIncentiveDistributor`, but the `initialize` function itself does not explicitly check for zero addresses (though the `slither-disable-next-line missing-zero-check` comment is present, this check should ideally be included in the function body). It modifies the `_roles`, `_roleAdmins`, `beacon`, `bgt`, `distributor`, and `beaconDepositContract` storage variables."
  },
  "RewardVaultFactory._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This is an internal override function required by the UUPSUpgradeable pattern. Its purpose is to define the access control mechanism for authorizing contract upgrades. This implementation restricts upgrades to only addresses holding the `DEFAULT_ADMIN_ROLE` using the `onlyRole(DEFAULT_ADMIN_ROLE)` modifier. It does not modify any storage variables itself but enforces a check based on the caller's role in the AccessControl storage (`_roles`). The `newImplementation` parameter is not used within the function body but is required by the UUPS standard."
  },
  "RewardVaultFactory.setBGTIncentiveDistributor": {
    "type": "external",
    "function_name": "setBGTIncentiveDistributor(address _bgtIncentiveDistributor)",
    "analysis_result": "This external function allows the `DEFAULT_ADMIN_ROLE` to set the address of the BGTIncentiveDistributor contract. It first checks if the provided `_bgtIncentiveDistributor` address is not `address(0)` using `ZeroAddress.selector.revertWith()`, reverting if it is. It then emits a `BGTIncentiveDistributorSet` event, logging the new and old addresses of the distributor. Finally, it updates the `bgtIncentiveDistributor` state variable with the new address. Access is restricted to the `DEFAULT_ADMIN_ROLE` by the `onlyRole` modifier. It reads the current value of `bgtIncentiveDistributor` and modifies it."
  },
  "RewardVaultFactory.createRewardVault": {
    "type": "external",
    "function_name": "createRewardVault(address stakingToken)",
    "analysis_result": "This external function is used to create a new RewardVault contract for a specific `stakingToken`. It first checks if a vault already exists for the given `stakingToken` by reading the `getVault` mapping. If `getVault[stakingToken]` is not `address(0)`, it returns the existing vault address without creating a new one. If no vault exists, it checks if the `stakingToken` address corresponds to a deployed contract by checking `stakingToken.code.length`. If the code length is 0 (indicating it's not a contract), it reverts with `NotAContract.selector.revertWith()`. It then calculates a unique `salt` for deterministic deployment using a keccak256 hash of the `stakingToken` address. It uses Solady's `LibClone.deployDeterministicERC1967BeaconProxy` to deploy a new RewardVault contract clone via the stored `beacon` address using the calculated `salt`. The address of the newly deployed vault is stored in the `getVault` mapping with the `stakingToken` as the key, and the vault address is also pushed to the `allVaults` array. A `VaultCreated` event is emitted with the `stakingToken` and the new `vault` address. Finally, it calls the `initialize` function on the newly deployed vault contract, passing the stored `beaconDepositContract`, `bgt`, `distributor`, and `stakingToken` addresses. It reads `getVault`, `beacon`, and `allVaults` and writes to `getVault` and `allVaults`. It calls an external function `initialize` on the newly created `RewardVault` contract."
  },
  "RewardVaultFactory.predictRewardVaultAddress": {
    "type": "external",
    "function_name": "predictRewardVaultAddress(address stakingToken)",
    "analysis_result": "This external view function allows predicting the address of a RewardVault that *would be* created for a given `stakingToken` using deterministic deployment. It calculates the same `salt` as the `createRewardVault` function using the keccak256 hash of the `stakingToken` address. It then calls Solady's `LibClone.predictDeterministicAddressERC1967BeaconProxy`, providing the `beacon` address, the calculated `salt`, and the address of the factory contract (`address(this)`) which acts as the deployer. This function does not deploy a contract or modify any state variables. It reads the `beacon` state variable and uses the `address(this)` implicit variable."
  },
  "RewardVaultFactory.allVaultsLength": {
    "type": "external",
    "function_name": "allVaultsLength()",
    "analysis_result": "This external view function returns the total number of RewardVaults created by this factory. It simply returns the `.length` property of the `allVaults` array. It reads the `allVaults` array's length. It does not modify any state variables."
  },
  "IBGT.staker": {
    "type": "external",
    "function_name": "staker() external view returns (address)",
    "analysis_result": "This function is a view function that returns the address of the BGT staker contract. It reads a storage variable intended to store the staker's address. It takes no parameters and returns an address."
  },
  "IBGT.activateBoostDelay": {
    "type": "external",
    "function_name": "activateBoostDelay() external view returns (uint32)",
    "analysis_result": "This function is a view function that returns the required delay (likely in blocks or time) before a queued boost can be activated. It reads a storage variable holding the activate boost delay duration. It takes no parameters and returns a uint32 value."
  },
  "IBGT.dropBoostDelay": {
    "type": "external",
    "function_name": "dropBoostDelay() external view returns (uint32)",
    "analysis_result": "This function is a view function that returns the required delay (likely in blocks or time) before a queued drop boost can be executed. It reads a storage variable holding the drop boost delay duration. It takes no parameters and returns a uint32 value."
  },
  "IBGT.whitelistSender": {
    "type": "external",
    "function_name": "whitelistSender(address sender, bool approved) external",
    "analysis_result": "This function is intended to control which addresses are allowed to transfer BGT tokens. According to the NatSpec, BGT is intended to be soul-bound to EOAs and only transferable by approved senders. This function allows a 'governance module' to approve or revoke the ability of a specific 'sender' address to transfer BGT. It takes the 'sender' address and a boolean 'approved' indicating whether to grant or revoke permission. This function likely modifies an internal mapping or list of approved senders. It emits the 'SenderWhitelisted' event."
  },
  "IBGT.mint": {
    "type": "external",
    "function_name": "mint(address distributor, uint256 amount) external",
    "analysis_result": "This function is used to create new BGT tokens and assign them to a 'distributor' address. The NatSpec indicates this function can only be called by a designated 'minter' address, which itself is set by governance. It takes the 'distributor' address and the 'amount' of BGT to mint. This function increases the total supply of BGT and the balance of the 'distributor'. It likely interacts with internal token balance storage and the total supply variable, similar to standard ERC20 minting, potentially calling an internal '_mint' function."
  },
  "IBGT.queueBoost": {
    "type": "external",
    "function_name": "queueBoost(bytes calldata pubkey, uint128 amount) external",
    "analysis_result": "This function allows `msg.sender` to enqueue an amount of their unboosted BGT balance for boosting a specific validator identified by 'pubkey'. The NatSpec specifies that it reverts if the caller doesn't have sufficient unboosted balance. It takes the validator's 'pubkey' (bytes) and the 'amount' of BGT to queue. This function likely decreases the user's unboosted balance and increases a 'queuedBoost' balance associated with the user and validator, updating an internal state related to boosting queues. It should emit the 'QueueBoost' event."
  },
  "IBGT.cancelBoost": {
    "type": "external",
    "function_name": "cancelBoost(bytes calldata pubkey, uint128 amount) external",
    "analysis_result": "This function allows `msg.sender` to cancel a previously queued boost for a validator identified by 'pubkey'. The NatSpec states it reverts if the caller doesn't have enough balance in the queued state for that validator. It takes the validator's 'pubkey' (bytes) and the 'amount' of BGT to remove from the queue. This function likely decreases the 'queuedBoost' balance for the user and validator and increases the user's unboosted balance. It should emit the 'CancelBoost' event."
  },
  "IBGT.activateBoost": {
    "type": "external",
    "function_name": "activateBoost(address user, bytes calldata pubkey) external returns (bool)",
    "analysis_result": "This function is used to transition queued boost balance for a specific 'user' and validator ('pubkey') into an active boost. The NatSpec indicates it's called by a 'sender' (likely the staker contract) on behalf of a 'user'. It takes the 'user' address and the validator's 'pubkey'. It returns false if the amount to activate is zero or if the 'activateBoostDelay' has not passed since the boost was queued. Otherwise, it activates the queued amount. This function likely moves BGT balance from a 'queuedBoost' state to a 'boosted' state for the user/validator pair, potentially updating total boosted amounts and the validator's 'boostees' balance. It should emit the 'ActivateBoost' event."
  },
  "IBGT.queueDropBoost": {
    "type": "external",
    "function_name": "queueDropBoost(bytes calldata pubkey, uint128 amount) external",
    "analysis_result": "This function allows `msg.sender` (the user) to enqueue an amount of their active boost balance for a specific validator ('pubkey') to be dropped. The NatSpec states it reverts if the user doesn't have enough currently boosted balance with that validator. It takes the validator's 'pubkey' and the 'amount' of BGT boost to queue for dropping. This function likely moves balance from the 'boosted' state to a 'dropBoostQueue' state for the user/validator. It should emit the 'QueueDropBoost' event."
  },
  "IBGT.cancelDropBoost": {
    "type": "external",
    "function_name": "cancelDropBoost(bytes calldata pubkey, uint128 amount) external",
    "analysis_result": "This function allows `msg.sender` (the user) to cancel a previously queued drop boost for a validator ('pubkey'). It takes the validator's 'pubkey' and the 'amount' of BGT boost to remove from the queued drop state. This function likely moves balance from the 'dropBoostQueue' state back to the 'boosted' state for the user/validator. It should emit the 'CancelDropBoost' event."
  },
  "IBGT.dropBoost": {
    "type": "external",
    "function_name": "dropBoost(address user, bytes calldata pubkey) external returns (bool)",
    "analysis_result": "This function is used to execute a queued drop boost, reducing the active boost balance for a specific 'user' and validator ('pubkey'). The NatSpec indicates it's called by a 'sender' (likely the staker contract) on behalf of a 'user'. It takes the 'user' address and the validator's 'pubkey'. It returns false if the amount to drop is zero or if the 'dropBoostDelay' has not passed since the drop was queued. Otherwise, it executes the drop. This function likely moves balance from the 'dropBoostQueue' state back to the user's unboosted balance, reducing the 'boosted' amount for the user/validator and potentially the validator's 'boostees' balance. It should emit the 'DropBoost' event."
  },
  "IBGT.boostedQueue": {
    "type": "external",
    "function_name": "boostedQueue(address account, bytes calldata pubkey) external view returns (uint32 blockNumberLast, uint128 balance)",
    "analysis_result": "This is a view function that returns the details of the queued boost for a specific 'account' targeting a particular validator 'pubkey'. It returns two values: `blockNumberLast` which likely indicates when the queue action last occurred (useful for delay checks), and `balance` which is the amount of BGT currently queued for boosting this validator by this account. It reads internal state related to queued boosts."
  },
  "IBGT.dropBoostQueue": {
    "type": "external",
    "function_name": "dropBoostQueue(address account, bytes calldata pubkey) external view returns (uint32 blockNumberLast, uint128 balance)",
    "analysis_result": "This is a view function that returns the details of the queued drop boost for a specific 'account' targeting a particular validator 'pubkey'. It returns two values: `blockNumberLast` which likely indicates when the queue drop action last occurred (useful for delay checks), and `balance` which is the amount of BGT currently queued for dropping from this validator's boost by this account. It reads internal state related to queued drop boosts."
  },
  "IBGT.queuedBoost": {
    "type": "external",
    "function_name": "queuedBoost(address account) external view returns (uint128)",
    "analysis_result": "This is a view function that returns the total amount of BGT that a specific 'account' has currently queued across all validators for boosting. It sums up the queued boost amounts for the given account. It reads internal state related to queued boosts."
  },
  "IBGT.boosted": {
    "type": "external",
    "function_name": "boosted(address account, bytes calldata pubkey) external view returns (uint128)",
    "analysis_result": "This is a view function that returns the amount of BGT that a specific 'account' is currently actively using to boost a particular validator 'pubkey'. It reads internal state related to active boosts for a user and validator."
  },
  "IBGT.boosts": {
    "type": "external",
    "function_name": "boosts(address account) external view returns (uint128)",
    "analysis_result": "This is a view function that returns the total amount of BGT that a specific 'account' is currently actively using for boosting across all validators. It sums up the active boosted amounts for the given account. It reads internal state related to active boosts."
  },
  "IBGT.boostees": {
    "type": "external",
    "function_name": "boostees(bytes calldata pubkey) external view returns (uint128)",
    "analysis_result": "This is a view function that returns the total amount of BGT that is currently actively boosting a specific validator 'pubkey' from all users combined. It sums up the active boosted amounts directed at this validator. It reads internal state related to validator boosts."
  },
  "IBGT.totalBoosts": {
    "type": "external",
    "function_name": "totalBoosts() external view returns (uint128)",
    "analysis_result": "This is a view function that returns the grand total amount of BGT currently being used for active boosts across all accounts and all validators. It represents the sum of all `boosts(account)` or all `boostees(pubkey)`. It reads a global state variable tracking total active boosts."
  },
  "IBGT.normalizedBoost": {
    "type": "external",
    "function_name": "normalizedBoost(bytes calldata pubkey) external view returns (uint256)",
    "analysis_result": "This is a view function used by the 'distributor' (likely the Block Reward Controller) to calculate the effective boost power of a specific validator ('pubkey') based on the outstanding active boosts attributed to it. The NatSpec suggests this is a calculated value, potentially involving the raw 'boostees' amount and possibly other factors, normalized for distribution purposes. It reads the 'boostees' amount for the given pubkey and potentially the 'totalBoosts' or total supply to perform the normalization calculation."
  },
  "IBGT.minter": {
    "type": "external",
    "function_name": "minter() external view returns (address)",
    "analysis_result": "This function is a view function that returns the address currently authorized to call the `mint` function. The NatSpec indicates this address is initially the Block Reward Controller. It reads a storage variable holding the minter's address. It takes no parameters and returns an address."
  },
  "IBGT.setMinter": {
    "type": "external",
    "function_name": "setMinter(address _minter) external",
    "analysis_result": "This function allows the governance module to change the address authorized to call the `mint` function. It takes the new minter address `_minter` as input. This function writes to a storage variable storing the minter address. It should only be callable by a designated governance address and emits the 'MinterChanged' event."
  },
  "IBGT.setStaker": {
    "type": "external",
    "function_name": "setStaker(address _staker) external",
    "analysis_result": "This function allows a privileged address (likely governance) to set or change the address of the BGT staker contract. It takes the new staker address `_staker` as input. This function writes to a storage variable storing the staker address. It should emit the 'StakerChanged' event."
  },
  "IBGT.setActivateBoostDelay": {
    "type": "external",
    "function_name": "setActivateBoostDelay(uint32 _activateBoostDelay) external",
    "analysis_result": "This function allows a privileged address (likely governance) to set or change the required delay for activating queued boosts. It takes the new delay `_activateBoostDelay` as input. This function writes to a storage variable storing the activate boost delay. It should emit the 'ActivateBoostDelayChanged' event."
  },
  "IBGT.setDropBoostDelay": {
    "type": "external",
    "function_name": "setDropBoostDelay(uint32 _dropBoostDelay) external",
    "analysis_result": "This function allows a privileged address (likely governance) to set or change the required delay for executing queued drop boosts. It takes the new delay `_dropBoostDelay` as input. This function writes to a storage variable storing the drop boost delay. It should emit the 'DropBoostDelayChanged' event."
  },
  "IBGT.redeem": {
    "type": "external",
    "function_name": "redeem(address receiver, uint256 amount) external",
    "analysis_result": "This function allows the caller (`msg.sender`) to exchange their BGT tokens for the native network token (BERA) at a 1:1 rate, sending the native token to the specified 'receiver' address. It takes the 'receiver' address and the 'amount' of BGT to redeem. This function likely burns the specified amount of BGT from `msg.sender`'s balance, checks if the contract holds sufficient native token reserves, and transfers the equivalent amount of native token to the 'receiver'. It decreases the caller's BGT balance, decreases the BGT total supply (via burning), and decreases the contract's native token balance. It should emit the 'Redeem' event."
  },
  "IBGT.unboostedBalanceOf": {
    "type": "external",
    "function_name": "unboostedBalanceOf(address account) external view returns (uint256)",
    "analysis_result": "This is a view function that returns the amount of BGT held by a specific 'account' that is NOT currently being used for active boosts or is not in the process of being queued for boosting/dropping. This is distinct from the total balance returned by `balanceOf()`. It reads the account's total balance and subtracts any amounts actively boosted or in boost queues to derive the unboosted amount."
  },
  "IBGT.burnExceedingReserves": {
    "type": "external",
    "function_name": "burnExceedingReserves() external",
    "analysis_result": "This function allows any caller to burn excess native network tokens (BERA) held by the BGT contract. The NatSpec explains that the contract might receive an amount of native token exceeding the current BGT supply plus outstanding rewards from the consensus layer. This function liquidates this excess BERA by sending it to the zero address (burning it). It checks the contract's native token balance against the BGT total supply and potentially outstanding rewards, then transfers the excess amount to `address(0)`. It emits the 'ExceedingReservesBurnt' event."
  },
  "IBGT.totalSupply": {
    "type": "external",
    "function_name": "totalSupply() external view returns (uint256)",
    "analysis_result": "Inherited from IERC20. Returns the total supply of BGT tokens in existence. Reads a storage variable tracking the total supply."
  },
  "IBGT.balanceOf": {
    "type": "external",
    "function_name": "balanceOf(address account) external view returns (uint256)",
    "analysis_result": "Inherited from IERC20. Returns the BGT token balance of a specific 'account'. Reads an internal mapping storing account balances."
  },
  "IBGT.transfer": {
    "type": "external",
    "function_name": "transfer(address recipient, uint256 amount) external returns (bool)",
    "analysis_result": "Inherited from IERC20. Transfers `amount` BGT tokens from the caller (`msg.sender`) to the `recipient` address. As per the NatSpec for `whitelistSender`, this function's direct use by EOAs might be restricted; it might only work if `msg.sender` is whitelisted or if called by a contract like the staker. It modifies sender's and recipient's balances and emits a Transfer event."
  },
  "IBGT.allowance": {
    "type": "external",
    "function_name": "allowance(address owner, address spender) external view returns (uint256)",
    "analysis_result": "Inherited from IERC20. Returns the amount of BGT tokens that a `spender` is allowed to spend on behalf of an `owner` using `transferFrom`. Reads an internal mapping storing allowances."
  },
  "IBGT.approve": {
    "type": "external",
    "function_name": "approve(address spender, uint256 amount) external returns (bool)",
    "analysis_result": "Inherited from IERC20. Allows a `spender` address to withdraw up to `amount` BGT tokens from the caller's (`msg.sender`) account. Modifies an internal mapping storing allowances and emits an Approval event."
  },
  "IBGT.transferFrom": {
    "type": "external",
    "function_name": "transferFrom(address sender, address recipient, uint256 amount) external returns (bool)",
    "analysis_result": "Inherited from IERC20. Transfers `amount` BGT tokens from the `sender` address to the `recipient` address, using the caller's allowance. The caller (`msg.sender`) must have been approved by the `sender` using `approve`. This function might also be subject to the sender whitelisting mechanism described for `whitelistSender`. It modifies sender's and recipient's balances, updates the allowance, and emits Transfer and potentially Approval events."
  },
  "IBGT.name": {
    "type": "external",
    "function_name": "name() external view returns (string memory)",
    "analysis_result": "Inherited from IERC20Metadata. Returns the name of the BGT token (e.g., \"BGT\"). Reads a storage variable storing the token name."
  },
  "IBGT.symbol": {
    "type": "external",
    "function_name": "symbol() external view returns (string memory)",
    "analysis_result": "Inherited from IERC20Metadata. Returns the symbol of the BGT token (e.g., \"BGT\"). Reads a storage variable storing the token symbol."
  },
  "IBGT.decimals": {
    "type": "external",
    "function_name": "decimals() external view returns (uint8)",
    "analysis_result": "Inherited from IERC20Metadata. Returns the number of decimal places used for BGT tokens (typically 18). Reads a storage variable storing the number of decimals."
  },
  "IBGT.delegate": {
    "type": "external",
    "function_name": "delegate(address delegatee) external",
    "analysis_result": "Inherited from IVotes. Delegates the caller's (`msg.sender`) voting power to the `delegatee` address. This function changes which address receives the caller's token balance for voting purposes. It modifies internal state related to voting delegations and emits a DelegateChanged event. It reads the caller's balance and potentially prior delegation information."
  },
  "IBGT.delegateBySig": {
    "type": "external",
    "function_name": "delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) external",
    "analysis_result": "Inherited from IVotes. Delegates the voting power of the address recovered from the signature to the `delegatee` address. This allows delegation without requiring the token holder to send a transaction directly, using an off-chain signed message. It takes the `delegatee` address, a unique `nonce` for the owner, an `expiry` timestamp, and the signature components (`v`, `r`, `s`). It recovers the signer's address, verifies the signature against a domain separator, nonce, and expiry, and then performs the delegation similar to `delegate`. It modifies internal state and emits a DelegateChanged event."
  },
  "IBGT.getVotes": {
    "type": "external",
    "function_name": "getVotes(address account) external view returns (uint256)",
    "analysis_result": "Inherited from IVotes. Returns the current amount of voting power for a specific `account`. This includes the account's own balance if they haven't delegated, or the sum of balances of accounts that have delegated *to* this account if it's a delegatee. Reads internal state related to token balances and delegations."
  },
  "IBGT.getPastVotes": {
    "type": "external",
    "function_name": "getPastVotes(address account, uint256 blockNumber) external view returns (uint256)",
    "analysis_result": "Inherited from IVotes. Returns the amount of voting power for a specific `account` at a past `blockNumber`. This requires checkpoints to be recorded when balances or delegations change. Reads historical internal state related to token balances and delegations at a given block."
  },
  "IBGT.getPastTotalSupply": {
    "type": "external",
    "function_name": "getPastTotalSupply(uint256 blockNumber) external view returns (uint256)",
    "analysis_result": "Inherited from IVotes. Returns the total supply of BGT tokens at a past `blockNumber`. This requires checkpoints to be recorded when the total supply changes. Reads historical internal state related to total supply at a given block."
  },
  "IRewardVaultFactory.setBGTIncentiveDistributor": {
    "type": "external",
    "function_name": "setBGTIncentiveDistributor(address _bgtIncentiveDistributor)",
    "analysis_result": "This external function is declared to set the address of the BGTIncentiveDistributor contract. It takes one address parameter, `_bgtIncentiveDistributor`, which is intended to be the new address for the distributor. The natspec indicates it should be callable only by an admin, implying an access control mechanism is expected in the implementing contract. It does not return a value. The interface indicates that the `BGTIncentiveDistributorSet` event should be emitted upon successful execution. As an interface, it does not contain implementation logic, storage variable modifications, or internal function calls; these are expected in a contract that implements this interface."
  },
  "IRewardVaultFactory.createRewardVault": {
    "type": "external",
    "function_name": "createRewardVault(address stakingToken)",
    "analysis_result": "This external function is declared to create a new reward vault associated with a specific staking token. It takes one address parameter, `stakingToken`, which is the address of the token for which the vault is being created. The natspec specifies that it should revert if the provided `stakingToken` is not a contract address, implying a check is required in the implementation. It is declared to return the address of the newly created vault. The interface indicates that the `VaultCreated` event should be emitted upon successful creation. As an interface, it only defines the function signature; the actual creation logic, checks, storage updates, and event emission would be present in an implementing contract."
  },
  "IRewardVaultFactory.VAULT_MANAGER_ROLE": {
    "type": "external",
    "function_name": "VAULT_MANAGER_ROLE()",
    "analysis_result": "This external view function is declared to return the `bytes32` value representing the VAULT_MANAGER_ROLE identifier. It takes no parameters and returns a `bytes32`. As an interface, it simply specifies that an implementing contract must expose a public constant or getter function with this signature and return type, likely related to role-based access control mechanisms."
  },
  "IRewardVaultFactory.VAULT_PAUSER_ROLE": {
    "type": "external",
    "function_name": "VAULT_PAUSER_ROLE()",
    "analysis_result": "This external view function is declared to return the `bytes32` value representing the VAULT_PAUSER_ROLE identifier. It takes no parameters and returns a `bytes32`. Similar to `VAULT_MANAGER_ROLE`, it signifies that an implementing contract must expose this value, likely for pausing functionalities within vaults."
  },
  "IRewardVaultFactory.getVault": {
    "type": "external",
    "function_name": "getVault(address stakingToken)",
    "analysis_result": "This external view function is declared to retrieve the address of the reward vault associated with a specific staking token. It takes one address parameter, `stakingToken`, representing the token for which the vault address is sought. It is declared to return the address of the corresponding vault. An implementing contract would typically use an internal mapping to store and retrieve vault addresses based on the staking token address."
  },
  "IRewardVaultFactory.allVaultsLength": {
    "type": "external",
    "function_name": "allVaultsLength()",
    "analysis_result": "This external view function is declared to return the total number of reward vaults that have been created by the factory. It takes no parameters and is declared to return a `uint256` value representing the count. An implementing contract would need to maintain a counter or data structure that allows determining the total number of deployed vaults."
  },
  "IRewardVaultFactory.bgtIncentiveDistributor": {
    "type": "external",
    "function_name": "bgtIncentiveDistributor()",
    "analysis_result": "This external view function is declared to return the current address of the BGTIncentiveDistributor contract that the factory is configured to use. It takes no parameters and returns an `address`. This function likely serves as a getter for a state variable holding the distributor's address in an implementing contract."
  },
  "IRewardVaultFactory.predictRewardVaultAddress": {
    "type": "external",
    "function_name": "predictRewardVaultAddress(address stakingToken)",
    "analysis_result": "This external view function is declared to predict the address where a new reward vault for a given staking token would be deployed using CREATE2. It takes one address parameter, `stakingToken`, which is typically used to derive a unique salt for the prediction. It is declared to return the predicted address of the vault. The actual prediction logic, involving the factory's address, the salt derived from the staking token, and the creation bytecode of the vault contract, would reside in the implementing contract."
  },
  "IBGTStaker.notifyRewardAmount": {
    "type": "external",
    "function_name": "notifyRewardAmount(uint256 reward)",
    "analysis_result": "This function is intended to notify the staking contract about a new amount of reward tokens available for distribution. It takes one parameter, `reward`, which is the amount of reward tokens (uint256). According to the NatSpec, this function can only be called by a specific 'fee collector' address, implying an access control mechanism in the implementing contract. The implementing contract would typically use this information to update state related to the total rewards for the current period and calculate the reward rate. It might also interact with the reward token contract."
  },
  "IBGTStaker.recoverERC20": {
    "type": "external",
    "function_name": "recoverERC20(address tokenAddress, uint256 tokenAmount)",
    "analysis_result": "This function allows the contract owner to recover arbitrary ERC20 tokens that might have been accidentally sent to the contract. It takes two parameters: `tokenAddress` (address) the address of the token to recover, and `tokenAmount` (uint256) the amount to recover. The NatSpec specifies that this function can only be called by the contract owner (implying access control) and will revert if the `tokenAddress` is the same as the reward token address, preventing the reward pool from being drained via this function. The implementation would involve a transfer of `tokenAmount` of the token at `tokenAddress` from the contract's balance to the owner's address. It is documented to emit the `Recovered` event."
  },
  "IBGTStaker.setRewardsDuration": {
    "type": "external",
    "function_name": "setRewardsDuration(uint256 _rewardsDuration)",
    "analysis_result": "This function is used to set the duration (in seconds) for which the current reward amount will be distributed. It takes one parameter, `_rewardsDuration` (uint256). The NatSpec states it can only be called by the contract owner (implying access control) and will revert if the current reward cycle has already started, preventing mid-cycle duration changes. The implementing contract will update a state variable storing the `rewardsDuration` and potentially recalculate the reward rate or period details based on the new duration."
  },
  "IBGTStaker.stake": {
    "type": "external",
    "function_name": "stake(address account, uint256 amount)",
    "analysis_result": "This function is used to deposit BGT tokens into the staking contract on behalf of a specific `account`. It takes two parameters: `account` (address) for whom the tokens are being staked, and `amount` (uint256) the quantity of BGT tokens to stake. A crucial constraint mentioned in the NatSpec is that this function can only be called by the 'BGT contract' itself, implying a specific integration point and access control check. The implementing contract would typically transfer the `amount` of BGT from the `account` to the staking contract and update the internal staked balance for the `account` and the total staked supply. It likely interacts with the BGT token contract."
  },
  "IBGTStaker.withdraw": {
    "type": "external",
    "function_name": "withdraw(address account, uint256 amount)",
    "analysis_result": "This function is used to withdraw BGT tokens from the staking contract for a specific `account`. It takes two parameters: `account` (address) for whom the tokens are being withdrawn, and `amount` (uint256) the quantity of BGT tokens to withdraw. Similar to the `stake` function, the NatSpec specifies that this function can only be called by the 'BGT contract', implying a specific integration point and access control check. The implementing contract would typically transfer the `amount` of BGT from the staking contract back to the `account` and update the internal staked balance for the `account` and the total staked supply. It likely interacts with the BGT token contract."
  },
  "IBGTStaker.getReward": {
    "type": "external",
    "function_name": "getReward() returns (uint256)",
    "analysis_result": "This function allows the caller (`msg.sender`) to claim their accrued reward tokens. It takes no parameters. It returns a `uint256` representing the amount of reward claimed. The NatSpec mentions it gets the reward 'for the caller'. The implementation would calculate the caller's eligible rewards based on their stake and the reward distribution logic (likely inheriting from `IStakingRewards`), transfer the calculated reward amount to the caller's address, and update internal state to mark these rewards as claimed. This function is a standard part of staking reward contracts."
  },
  "IBeaconDeposit.getOperator": {
    "type": "external",
    "function_name": "getOperator(bytes calldata pubkey) external view returns (address)",
    "analysis_result": "This is a view function that returns the operator address associated with a given validator public key (`pubkey`). It is intended to read a mapping or similar state variable in an implementing contract that stores the operator for each validator. The function takes a `bytes calldata pubkey` as input. It returns an `address`. The comment indicates it returns the zero address if the pubkey is not registered. This function does not modify state."
  },
  "IBeaconDeposit.deposit": {
    "type": "external",
    "function_name": "deposit(bytes calldata pubkey, bytes calldata credentials, bytes calldata signature, address operator) external payable",
    "analysis_result": "This is a payable external function used to deposit Ether (or equivalent native token) for staking on the Beaconchain. It can be used for either creating a new validator or topping up an existing one. It takes `bytes calldata pubkey` (validator's public key), `bytes calldata credentials` (withdrawal credentials), `bytes calldata signature` (used only on the first deposit for a pubkey), and `address operator` (the address designated for POL mechanics). The function is `payable`, meaning it can receive value. It's intended to record the deposit amount (implicitly `msg.value`) against the validator identified by `pubkey`. The `operator` address is likely stored and associated with the `pubkey`. The comment mentions it reverts if the operator is already set and a non-zero `operator` is passed, implying that the operator can only be set on the first deposit or subsequent calls must pass the zero address if the operator is already set. Upon successful execution, it emits the `Deposit` event with details including `pubkey`, `credentials`, the deposited amount (`msg.value` likely converted to Gwei as per comment), `signature`, and an index (likely an internal deposit counter)."
  },
  "IBeaconDeposit.requestOperatorChange": {
    "type": "external",
    "function_name": "requestOperatorChange(bytes calldata pubkey, address newOperator) external",
    "analysis_result": "This external function is used by the current operator of a validator to request a change to a new operator address. It takes the `bytes calldata pubkey` of the validator and the `address newOperator` as parameters. The comment specifies that 'Only the current operator can request a change', indicating an access control check based on the current operator associated with the `pubkey` and `msg.sender`. The function is intended to update a state variable (likely a mapping) to store the `newOperator` as a 'queued' or pending operator and record the timestamp of the request. Upon success, it emits the `OperatorChangeQueued` event, including `pubkey`, `queuedOperator` (`newOperator`), `currentOperator` (the operator at the time of the request), and `queuedTimestamp`."
  },
  "IBeaconDeposit.cancelOperatorChange": {
    "type": "external",
    "function_name": "cancelOperatorChange(bytes calldata pubkey) external",
    "analysis_result": "This external function allows the current operator of a validator to cancel a previously requested operator change. It takes the `bytes calldata pubkey` of the validator whose change is being cancelled. The comment states 'Only the current operator can cancel the change', implying an access control check comparing `msg.sender` to the current operator associated with the `pubkey`. The function's purpose is to clear the 'queued' or pending operator state for the given `pubkey`. Upon successful cancellation, it emits the `OperatorChangeCancelled` event, including the `pubkey`."
  },
  "IBeaconDeposit.acceptOperatorChange": {
    "type": "external",
    "function_name": "acceptOperatorChange(bytes calldata pubkey) external",
    "analysis_result": "This external function is called by the proposed new operator to finalize an operator change request. It takes the `bytes calldata pubkey` of the validator. The comment states 'Only the new operator can accept the change', indicating an access control check where `msg.sender` must match the address previously set as the 'queued' operator for the given `pubkey`. The comment also mentions 'Reverts if the queue delay has not passed', indicating a time-based check based on the timestamp recorded when `requestOperatorChange` was called. If both checks pass, the function updates the primary state variable (mapping) storing the current operator for the `pubkey` to the address of `msg.sender`. It then emits the `OperatorUpdated` event, including `pubkey`, `newOperator` (`msg.sender`), and `previousOperator` (the operator before this update)."
  },
  "IRewardVault.distributor": {
    "type": "external view",
    "function_name": "distributor() external view returns (address)",
    "analysis_result": "This is a getter function that allows anyone to query the address currently authorized to distribute rewards to the vault. It is a view function, meaning it does not modify the contract's state. It reads a state variable, likely named `distributor`, which stores the address of the authorized distributor."
  },
  "IRewardVault.operator": {
    "type": "external view",
    "function_name": "operator(address account) external view returns (address)",
    "analysis_result": "This is a getter function to retrieve the address of the operator set by a specific `account`. The operator is an address that is allowed to claim and manage rewards on behalf of the `account`. It takes the `account` address as input and returns the address of its designated operator. It is a view function and reads a state variable, likely a mapping from `account` address to `operator` address."
  },
  "IRewardVault.getWhitelistedTokensCount": {
    "type": "external view",
    "function_name": "getWhitelistedTokensCount() external view returns (uint256)",
    "analysis_result": "This is a getter function that returns the current number of incentive tokens that have been whitelisted by the contract owner. It is a view function and reads a state variable that keeps track of the count of whitelisted tokens."
  },
  "IRewardVault.getWhitelistedTokens": {
    "type": "external view",
    "function_name": "getWhitelistedTokens() external view returns (address[] memory)",
    "analysis_result": "This is a getter function that returns an array containing the addresses of all incentive tokens that are currently whitelisted in the contract. It is a view function and reads a state variable or iterates through a mapping/list storing the whitelisted token addresses."
  },
  "IRewardVault.getTotalDelegateStaked": {
    "type": "external view",
    "function_name": "getTotalDelegateStaked(address account) external view returns (uint256)",
    "analysis_result": "This function returns the total amount of staking tokens that have been staked by *any* delegate on behalf of the specified `account`. It takes the `account` address as input and returns the total sum of stakes associated with that account, deposited by various delegates. It is a view function and likely reads from a mapping that aggregates delegate stakes for a given account."
  },
  "IRewardVault.getDelegateStake": {
    "type": "external view",
    "function_name": "getDelegateStake(address account, address delegate) external view returns (uint256)",
    "analysis_result": "This function returns the specific amount of staking tokens that a particular `delegate` address has staked on behalf of a specific `account` address. It takes both the `account` and `delegate` addresses as inputs and returns the corresponding staked amount. It is a view function and likely reads from a nested mapping or equivalent structure storing delegate stakes per account."
  },
  "IRewardVault.initialize": {
    "type": "external",
    "function_name": "initialize(address _berachef, address _bgt, address _distributor, address _stakingToken) external",
    "analysis_result": "This function is intended for initializing the vault contract after deployment. It is expected to be called only once, likely by the factory contract that deployed it. It sets crucial initial parameters like the addresses of the berachef contract, the BGT token, the initial reward distributor, and the staking token. It modifies state variables storing these addresses and likely flips an initialization flag to prevent future calls. It is permissioned, expected to be callable only during initial deployment."
  },
  "IRewardVault.setDistributor": {
    "type": "external",
    "function_name": "setDistributor(address _rewardDistribution) external",
    "analysis_result": "This function allows the factory owner (or equivalent admin role) to change the address of the authorized reward distributor. It takes the new distributor address `_rewardDistribution` as input. It modifies a state variable (`distributor`) to the new address. It is a permissioned function, restricted to the factory owner or administrator. It is expected to emit the `DistributorSet` event upon successful execution."
  },
  "IRewardVault.notifyRewardAmount": {
    "type": "external",
    "function_name": "notifyRewardAmount(bytes calldata pubkey, uint256 reward) external",
    "analysis_result": "This function is called by the authorized `distributor` to inform the vault about a new amount of BGT `reward` available for a specific validator identified by its `pubkey`. It is part of the reward distribution mechanism. It likely updates internal accounting to track pending rewards associated with validators or their operators. It is a permissioned function, callable only by the address stored in the `distributor` state variable."
  },
  "IRewardVault.recoverERC20": {
    "type": "external",
    "function_name": "recoverERC20(address tokenAddress, uint256 tokenAmount) external",
    "analysis_result": "This administrative function allows the factory owner (or equivalent admin role) to recover unintended or accidentally transferred ERC20 tokens from the vault contract. It takes the `tokenAddress` and `tokenAmount` to recover as inputs. It performs an ERC20 `transfer` or `transferFrom` call to send the specified amount of the token to a designated recovery address (likely the owner or factory). It should include checks to prevent recovering core contract tokens like the staking token or BGT. It modifies the balance of the specified token in the vault and the recipient's address. It is a permissioned function. It is expected to emit the `Recovered` event."
  },
  "IRewardVault.setRewardsDuration": {
    "type": "external",
    "function_name": "setRewardsDuration(uint256 _rewardsDuration) external",
    "analysis_result": "This administrative function allows the factory owner (or equivalent admin role) to change the duration over which the notified rewards are distributed. It takes the new duration `_rewardsDuration` as input. It modifies a state variable storing the reward duration. This affects the rate at which rewards accrue to stakers. It is a permissioned function."
  },
  "IRewardVault.whitelistIncentiveToken": {
    "type": "external",
    "function_name": "whitelistIncentiveToken(address token, uint256 minIncentiveRate, address manager) external",
    "analysis_result": "This administrative function allows the factory owner (or equivalent admin role) to add a new ERC20 token to the list of whitelisted tokens that can be used as incentives. It takes the token address `token`, a `minIncentiveRate` (minimum amount of this token to incentivize per BGT emission), and the address of the authorized `manager` for this token as inputs. It adds the token to a list/mapping of whitelisted tokens and stores its associated minimum rate and manager. It likely updates the count of whitelisted tokens. It is a permissioned function. It is expected to emit the `IncentiveTokenWhitelisted` event."
  },
  "IRewardVault.removeIncentiveToken": {
    "type": "external",
    "function_name": "removeIncentiveToken(address token) external",
    "analysis_result": "This administrative function allows the factory vault manager (or equivalent admin role) to remove a whitelisted incentive token from the list. It takes the token address `token` as input. It removes the token's entry from the whitelisted list/mapping and potentially updates the count. It is a permissioned function. It is expected to emit the `IncentiveTokenRemoved` event."
  },
  "IRewardVault.setMaxIncentiveTokensCount": {
    "type": "external",
    "function_name": "setMaxIncentiveTokensCount(uint8 _maxIncentiveTokensCount) external",
    "analysis_result": "This administrative function allows the factory owner (or equivalent admin role) to update the maximum number of incentive tokens that can be whitelisted at any given time. It takes the new maximum count `_maxIncentiveTokensCount` as input. It modifies a state variable storing this maximum count. It is a permissioned function. It is expected to emit the `MaxIncentiveTokensCountUpdated` event."
  },
  "IRewardVault.pause": {
    "type": "external",
    "function_name": "pause() external",
    "analysis_result": "This administrative function allows the factory vault pauser (or equivalent admin role) to pause certain operations of the vault, typically mutative functions like staking, withdrawing, claiming rewards, etc. It likely sets a boolean state variable (e.g., `paused`) to true. It is a permissioned function."
  },
  "IRewardVault.unpause": {
    "type": "external",
    "function_name": "unpause() external",
    "analysis_result": "This administrative function allows the factory vault manager (or equivalent admin role) to unpause the vault, restoring normal operations. It likely sets a boolean state variable (e.g., `paused`) to false. It is a permissioned function."
  },
  "IRewardVault.exit": {
    "type": "external",
    "function_name": "exit(address recipient) external",
    "analysis_result": "This function allows the account holder (not an operator) to exit the staking vault. This action is expected to withdraw the user's self-staked tokens *and* claim any accumulated BGT rewards in a single call. It takes the address `recipient` where the BGT reward should be sent. It likely calculates pending BGT rewards, transfers the BGT to the recipient, transfers the user's staked tokens back to the user's address, and updates the user's staking and reward accounting balances to zero. It modifies state variables tracking user stake and reward balances and performs ERC20 transfers. It is likely permissioned such that only the account holder can call it for themselves."
  },
  "IRewardVault.getReward": {
    "type": "external",
    "function_name": "getReward(address account, address recipient) external returns (uint256)",
    "analysis_result": "This function allows an `account` holder or their designated `operator` to claim accumulated BGT rewards. It takes the `account` whose rewards are being claimed and the `recipient` address to send the rewards to. It calculates the accrued BGT rewards for the specified `account`, transfers the calculated amount to the `recipient`, and updates the `account`'s reward balance to zero. It returns the amount of BGT claimed. It modifies state variables tracking reward balances and performs an ERC20 transfer of BGT. It is permissioned to be callable by either the `account` itself or its set `operator`."
  },
  "IRewardVault.stake": {
    "type": "external",
    "function_name": "stake(uint256 amount) external",
    "analysis_result": "This function allows the caller (`msg.sender`) to stake `amount` of the designated staking token (`STAKING_TOKEN`) into the vault on their own behalf. It requires the caller to have approved the vault to spend the staking token. It calls `transferFrom` on the staking token contract to pull tokens from the caller's address to the vault. It updates the caller's staked balance in a state variable and likely updates a total staked supply state variable. It modifies stake accounting state. It does not emit an explicit 'staked' event, but might be covered by `delegateStake` depending on internal logic, or simply update balances without an event."
  },
  "IRewardVault.delegateStake": {
    "type": "external",
    "function_name": "delegateStake(address account, uint256 amount) external",
    "analysis_result": "This function allows the caller (`msg.sender`) to stake `amount` of the designated staking token on behalf of another `account`. This is the 'delegate' functionality. It requires the caller to have approved the vault to spend the staking token. It calls `transferFrom` on the staking token contract to pull tokens from the caller's address to the vault. It updates the staked balance associated with the target `account` and the specific `delegate` (`msg.sender`). It also likely updates the total delegate stake for that `account` and the overall total staked supply. It modifies state variables tracking delegate stakes per account and total stakes. It is expected to emit the `DelegateStaked` event."
  },
  "IRewardVault.withdraw": {
    "type": "external",
    "function_name": "withdraw(uint256 amount) external",
    "analysis_result": "This function allows the caller (`msg.sender`) to withdraw a specified `amount` of staking tokens that they have previously staked on their own behalf. It checks if the caller has sufficient self-staked balance. It updates the caller's self-staked balance state variable by reducing it by `amount`. It transfers the `amount` of staking tokens from the vault contract back to the caller's address using an ERC20 `transfer` call. It also updates the total staked supply. It modifies stake accounting state."
  },
  "IRewardVault.delegateWithdraw": {
    "type": "external",
    "function_name": "delegateWithdraw(address account, uint256 amount) external",
    "analysis_result": "This function allows the caller (`msg.sender`), acting as a delegate, to withdraw a specified `amount` of staking tokens that they previously staked on behalf of the specified `account`. It checks if the calling `delegate` has sufficient stake recorded for the `account`. It updates the delegate's stake balance for that `account` by reducing it by `amount`. It transfers the `amount` of staking tokens from the vault contract back to the calling `delegate`'s address using an ERC20 `transfer` call. It also updates the total delegate stake for that `account` and the overall total staked supply. It modifies state variables tracking delegate stakes per account and total stakes. It is expected to emit the `DelegateWithdrawn` event."
  },
  "IRewardVault.setOperator": {
    "type": "external",
    "function_name": "setOperator(address _operator) external",
    "analysis_result": "This function allows the caller (`msg.sender`) to designate another address `_operator` that will be allowed to claim and manage rewards on their behalf. It takes the `_operator` address as input. It modifies a state variable (likely a mapping from `msg.sender` to `_operator`) to record this designation. It is expected to emit the `OperatorSet` event."
  },
  "IRewardVault.updateIncentiveManager": {
    "type": "external",
    "function_name": "updateIncentiveManager(address token, address newManager) external",
    "analysis_result": "This administrative function allows the factory owner (or equivalent admin role) to change the authorized manager for a specific whitelisted incentive `token`. It takes the `token` address and the `newManager` address as inputs. It updates the state variable storing the manager address for the specified token. It is a permissioned function. It is expected to emit the `IncentiveManagerChanged` event."
  },
  "IRewardVault.addIncentive": {
    "type": "external",
    "function_name": "addIncentive(address token, uint256 amount, uint256 incentiveRate) external",
    "analysis_result": "This function allows the authorized `manager` for a specific whitelisted incentive `token` to add `amount` of that token to the vault's incentive pool and set its `incentiveRate`. It requires the caller (`msg.sender`) to be the designated manager for the `token`. It checks if the token is whitelisted and the caller is the manager. It calls `transferFrom` on the incentive token contract to pull the `amount` from the caller's address to the vault. It updates internal state variables tracking the total incentive amount available for the token and its associated `incentiveRate`. It modifies state variables related to incentive accounting and performs an ERC20 transfer. It is a permissioned function. It is expected to emit the `IncentiveAdded` event."
  },
  "IRewardVault.accountIncentives": {
    "type": "external",
    "function_name": "accountIncentives(address token, uint256 amount) external",
    "analysis_result": "This function allows the authorized `manager` for a specific whitelisted incentive `token` to account for `amount` of tokens that have already been transferred to the vault (e.g., via direct `IERC20.transfer` instead of `addIncentive`). It takes the `token` address and the `amount` to account for as inputs. It checks if the token is whitelisted and the caller is the manager. It updates internal state variables tracking the total incentive amount available for the token by adding the `amount`. It does *not* perform a token transfer itself, assuming the tokens are already in the vault. It modifies state variables related to incentive accounting. It is a permissioned function."
  },
  "IFeeCollector.queuePayoutAmountChange": {
    "type": "external",
    "function_name": "queuePayoutAmountChange(uint256 _newPayoutAmount)",
    "analysis_result": "This function is declared to be callable externally and is intended for the admin role. Its purpose is to queue a new value for the payout amount. The function takes one parameter, `_newPayoutAmount`, which is the desired new amount. According to the comments, this amount is not set immediately but is queued and will become the active `payoutAmount` after the next fee claim. It likely modifies an internal state variable storing the queued payout amount. The NatSpec comments suggest it emits the `QueuedPayoutAmount` event upon successful queuing."
  },
  "IFeeCollector.payoutToken": {
    "type": "external",
    "function_name": "payoutToken() view returns (address)",
    "analysis_result": "This is a public getter function declared as external and view. It returns the address of the ERC-20 token that is designated as the 'payout token'. This token is used to pay the required fee when claiming other dapp fees. It reads an internal state variable storing the payout token address."
  },
  "IFeeCollector.queuedPayoutAmount": {
    "type": "external",
    "function_name": "queuedPayoutAmount() view returns (uint256)",
    "analysis_result": "This is a public getter function declared as external and view. It returns the amount of the payout token that has been recently queued via `queuePayoutAmountChange`. This value represents the next payout amount that will become active after the subsequent fee claim. It reads an internal state variable storing the queued payout amount."
  },
  "IFeeCollector.payoutAmount": {
    "type": "external",
    "function_name": "payoutAmount() view returns (uint256)",
    "analysis_result": "This is a public getter function declared as external and view. It returns the current active amount of the payout token that is required to be paid by a caller in order to claim accumulated dapp fees for a specific token. This amount operates on a 'first come first serve' basis. It reads an internal state variable storing the current payout amount."
  },
  "IFeeCollector.rewardReceiver": {
    "type": "external",
    "function_name": "rewardReceiver() view returns (address)",
    "analysis_result": "This is a public getter function declared as external and view. It returns the address of the contract or account that is designated to receive the payout tokens paid by users claiming dapp fees. This receiver is also intended to be notified when a fee claim occurs. It reads an internal state variable storing the reward receiver address."
  },
  "IFeeCollector.claimFees": {
    "type": "external",
    "function_name": "claimFees(address recipient, address[] calldata feeTokens)",
    "analysis_result": "This function is declared as external and allows a caller to claim accumulated dapp fees held by the contract for a specified list of fee tokens. The caller must pay the current `payoutAmount` in `payoutToken`. This payout amount is transferred to the `rewardReceiver`. The claimed fees (`feeTokens`) are transferred to the `recipient` address provided as a parameter. The comment explicitly notes that this function does not provide slippage protection. After a claim, if a new amount was queued, the `payoutAmount` is updated to the `queuedPayoutAmount`. The function is declared to emit a `FeesClaimed` event for each token successfully claimed, indicating the caller, recipient, fee token address, and the amount transferred."
  },
  "IFeeCollector.donate": {
    "type": "external",
    "function_name": "donate(uint256 amount)",
    "analysis_result": "This function is declared as external and allows any user to directly send `amount` of the `payoutToken` to the designated `rewardReceiver`. The comment clarifies that the token sent must be the `payoutToken`. If the `amount` transferred is greater than or equal to the current `payoutAmount`, it triggers a notification mechanism to the `rewardReceiver`, similar to the notification during a fee claim. It is declared to emit the `PayoutDonated` event upon execution."
  },
  "IFeeCollector.pause": {
    "type": "external",
    "function_name": "pause()",
    "analysis_result": "This function is declared as external and is intended to allow a designated 'pauser' role to pause the contract's operations, likely restricting functions like `claimFees`. It modifies an internal state variable representing the pause status. Standard implementations of pausing emit a `Paused` event."
  },
  "IFeeCollector.unpause": {
    "type": "external",
    "function_name": "unpause()",
    "analysis_result": "This function is declared as external and is intended to allow a designated 'manager' role to unpause the contract, resuming normal operations after a pause. It modifies an internal state variable representing the pause status. Standard implementations of unpausing emit an `Unpaused` event."
  },
  "IBeraChef.getActiveRewardAllocation": {
    "type": "external view",
    "function_name": "getActiveRewardAllocation(bytes calldata valPubkey) returns (RewardAllocation memory)",
    "analysis_result": "This function is a public getter designed to retrieve the currently active reward allocation configuration for a validator. It takes the validator's public key (`valPubkey`) as input. It is marked as `view`, indicating it does not modify the contract's state. The function returns a `RewardAllocation` struct, which contains the start block and an array of `Weight` structs defining how rewards are distributed among receivers (vaults)."
  },
  "IBeraChef.getQueuedRewardAllocation": {
    "type": "external view",
    "function_name": "getQueuedRewardAllocation(bytes calldata valPubkey) returns (RewardAllocation memory)",
    "analysis_result": "This function is a public getter to retrieve the reward allocation configuration that has been queued for future activation by a specific validator. It takes the validator's public key (`valPubkey`) as input and returns a `RewardAllocation` struct. It is marked as `view`."
  },
  "IBeraChef.getSetActiveRewardAllocation": {
    "type": "external view",
    "function_name": "getSetActiveRewardAllocation(bytes calldata valPubkey) returns (RewardAllocation memory)",
    "analysis_result": "This function retrieves the reward allocation configuration that was explicitly set by a validator, regardless of whether it is currently active or meets validation criteria. It takes the validator's public key (`valPubkey`) and returns a `RewardAllocation` struct. It is marked as `view`."
  },
  "IBeraChef.getDefaultRewardAllocation": {
    "type": "external view",
    "function_name": "getDefaultRewardAllocation() returns (RewardAllocation memory)",
    "analysis_result": "This function is a public getter that returns the default reward allocation configuration. This default allocation is used for validators who have not set their own. It takes no parameters and returns a `RewardAllocation` struct. It is marked as `view`."
  },
  "IBeraChef.isQueuedRewardAllocationReady": {
    "type": "external view",
    "function_name": "isQueuedRewardAllocationReady(bytes calldata valPubkey, uint256 blockNumber) returns (bool)",
    "analysis_result": "This function checks if a validator's queued reward allocation is ready to be activated at a specific `blockNumber`. It takes the validator's public key (`valPubkey`) and a target `blockNumber` as input. It likely compares the queued allocation's `startBlock` with the provided `blockNumber` and considers the `rewardAllocationBlockDelay`. It returns a boolean indicating readiness. It is marked as `view`."
  },
  "IBeraChef.isReady": {
    "type": "external view",
    "function_name": "isReady() returns (bool)",
    "analysis_result": "This function is a system readiness check. It indicates whether the BeraChef contract is fully initialized and ready for use. According to the comment, this depends on whether the default reward allocation has been set by the governance module. It takes no parameters, returns a boolean, and is marked as `view`."
  },
  "IBeraChef.getValQueuedCommissionOnIncentiveTokens": {
    "type": "external view",
    "function_name": "getValQueuedCommissionOnIncentiveTokens(bytes calldata valPubkey) returns (QueuedCommissionRateChange memory)",
    "analysis_result": "This function retrieves the details of the queued commission rate change for a specific validator on incentive tokens. It takes the validator's public key (`valPubkey`) as input and returns a `QueuedCommissionRateChange` struct, which includes the block number the change was queued and the target commission rate. It is marked as `view`."
  },
  "IBeraChef.getValCommissionOnIncentiveTokens": {
    "type": "external view",
    "function_name": "getValCommissionOnIncentiveTokens(bytes calldata valPubkey) returns (uint96)",
    "analysis_result": "This function retrieves the current active commission rate for a specific validator (`valPubkey`) on incentive tokens. It is marked as `view` and returns a `uint96` value representing the commission rate. The comment notes a default rate of 5% if the commission has never been explicitly set."
  },
  "IBeraChef.getValidatorIncentiveTokenShare": {
    "type": "external view",
    "function_name": "getValidatorIncentiveTokenShare(bytes calldata valPubkey, uint256 incentiveTokenAmount) returns (uint256)",
    "analysis_result": "This function calculates the portion of a given `incentiveTokenAmount` that corresponds to the validator's (`valPubkey`) current active commission rate. It takes the validator's public key and the total incentive token amount as input, performs the calculation based on the commission rate obtained via internal logic (or `getValCommissionOnIncentiveTokens`), and returns the validator's share as a `uint256`. It is marked as `view`."
  },
  "IBeraChef.setMaxNumWeightsPerRewardAllocation": {
    "type": "external",
    "function_name": "setMaxNumWeightsPerRewardAllocation(uint8 _maxNumWeightsPerRewardAllocation)",
    "analysis_result": "This is an administrative function to set the maximum allowed number of weight entries (`Weight` structs) that can be included in a single `RewardAllocation`. It takes a `uint8` representing the new maximum value. The function modifies the contract's state and is likely restricted to a privileged account (e.g., governance module or owner) based on the 'ADMIN FUNCTIONS' comment block."
  },
  "IBeraChef.setMaxWeightPerVault": {
    "type": "external",
    "function_name": "setMaxWeightPerVault(uint96 _maxWeightPerVault)",
    "analysis_result": "This is an administrative function to set the maximum percentage weight that can be assigned to any single vault (`receiver`) within a reward allocation. It takes a `uint96` value (where 10000 equals 100%) as input. It modifies the contract's state and is likely restricted to a privileged account."
  },
  "IBeraChef.setRewardAllocationBlockDelay": {
    "type": "external",
    "function_name": "setRewardAllocationBlockDelay(uint64 _rewardAllocationBlockDelay)",
    "analysis_result": "This is an administrative function to set the minimum number of blocks that must pass between queuing a new reward allocation and when it becomes eligible for activation. It takes a `uint64` value representing the delay in blocks. It modifies the contract's state and is likely restricted to a privileged account."
  },
  "IBeraChef.setVaultWhitelistedStatus": {
    "type": "external",
    "function_name": "setVaultWhitelistedStatus(address receiver, bool isWhitelisted, string memory metadata)",
    "analysis_result": "This is an administrative function used to update the whitelisted status of a vault address. It takes the `receiver` address, a `bool` (`isWhitelisted`) to set the status (true for whitelisting, false for removing from whitelist), and a `metadata` string to associate information with the vault. The comment explicitly states that this function must be called by the governance module account. It modifies the contract's state by updating the whitelisted status and metadata for the `receiver` address."
  },
  "IBeraChef.updateWhitelistedVaultMetadata": {
    "type": "external",
    "function_name": "updateWhitelistedVaultMetadata(address receiver, string memory metadata)",
    "analysis_result": "This is an administrative function to update the metadata string associated with an *already whitelisted* vault address. It takes the `receiver` address and the new `metadata` string. The function reverts if the provided `receiver` address is not currently whitelisted. The comment explicitly states this must be called by the governance module account. It modifies the contract's state by updating the metadata for the whitelisted `receiver` address."
  },
  "IBeraChef.setDefaultRewardAllocation": {
    "type": "external",
    "function_name": "setDefaultRewardAllocation(RewardAllocation calldata rewardAllocation)",
    "analysis_result": "This is an administrative function to set the global default reward allocation that is used for validators who do not have their own configured. It takes a `RewardAllocation` struct as input. The comment explicitly states this must be called by the governance module account. It modifies the contract's state by updating the default reward allocation."
  },
  "IBeraChef.queueNewRewardAllocation": {
    "type": "external",
    "function_name": "queueNewRewardAllocation(bytes calldata valPubkey, uint64 startBlock, Weight[] calldata weights)",
    "analysis_result": "This function allows a validator (identified by `valPubkey`) to queue a new reward allocation configuration. The `startBlock` specifies when this configuration should ideally become active, and `weights` define the distribution. The function includes validation logic: the sum of weights must equal 100% (1e4), and all receiver addresses in `weights` must be whitelisted vaults. It reverts if a reward allocation is already queued for the validator. It modifies the contract's state by storing the new queued reward allocation for the validator."
  },
  "IBeraChef.activateReadyQueuedRewardAllocation": {
    "type": "external",
    "function_name": "activateReadyQueuedRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This function transitions a validator's (`valPubkey`) queued reward allocation to the active state, but only if it meets the readiness criteria (checked using internal logic similar to `isQueuedRewardAllocationReady`). It is intended to be called by the distribution contract. It modifies the contract's state by moving the queued allocation to the active allocation slot for the validator."
  },
  "IBeraChef.setCommissionChangeDelay": {
    "type": "external",
    "function_name": "setCommissionChangeDelay(uint64 _commissionChangeDelay)",
    "analysis_result": "This is a setter function to configure the required block delay before a validator's queued commission rate change on incentive tokens can become active. It takes a `uint64` value for the delay. The comment explicitly states that only the contract owner can call this function. It modifies the contract's state by setting the commission change delay parameter."
  },
  "IBeraChef.queueValCommission": {
    "type": "external",
    "function_name": "queueValCommission(bytes calldata valPubkey, uint96 commissionRate)",
    "analysis_result": "This function allows the operator address associated with a validator (`valPubkey`) to queue a new commission rate for incentive tokens. It takes the target `commissionRate` (`uint96`, where 10000 is 100%). The comment states it reverts if a commission change is already pending for this validator. It modifies the contract's state by storing the new commission rate and the block number it was queued for the validator."
  },
  "IBeraChef.activateQueuedValCommission": {
    "type": "external",
    "function_name": "activateQueuedValCommission(bytes calldata valPubkey)",
    "analysis_result": "This function activates a previously queued commission rate change for a validator (`valPubkey`) on incentive tokens. This transition likely occurs only after the configured `commissionChangeDelay` has passed since the commission rate was queued. It modifies the contract's state by making the queued commission rate the active one for the validator."
  },
  "IBGTIncentiveDistributor.incentiveTokensPerValidator": {
    "type": "external view",
    "function_name": "incentiveTokensPerValidator(bytes calldata pubkey, address token) external view returns (uint256)",
    "analysis_result": "This external view function is designed to query the amount of a specific incentive token currently held within the contract for a particular validator. It takes the validator's public key (`pubkey`) and the token contract address (`token`) as input. It reads a storage variable, likely a nested mapping (e.g., mapping(bytes => mapping(address => uint256))), to retrieve the stored balance for that validator and token pair. This function does not modify any storage variables and is intended for public querying of the contract's state regarding validator incentives. It does not emit any events."
  },
  "IBGTIncentiveDistributor.setRewardClaimDelay": {
    "type": "external",
    "function_name": "setRewardClaimDelay(uint64 _delay) external",
    "analysis_result": "This external function allows setting the delay period (in seconds) that must pass after reward metadata is updated before the corresponding rewards can be claimed. It takes a `uint64` value, `_delay`, as the new delay duration. This function modifies a storage variable that stores the `rewardClaimDelay`. It is restricted by an access control mechanism, requiring the caller to have the `DEFAULT_ADMIN_ROLE`. Upon successful execution, it emits the `RewardClaimDelaySet` event, indicating the new delay value."
  },
  "IBGTIncentiveDistributor.receiveIncentive": {
    "type": "external",
    "function_name": "receiveIncentive(bytes calldata pubkey, address token, uint256 _amount) external",
    "analysis_result": "This external function facilitates the receipt of incentive tokens into the contract, designating them for a specific validator. The caller is expected to have previously approved the contract to spend the specified `_amount` of `token` on their behalf. The function takes the validator's `pubkey`, the `token` address, and the `_amount` of tokens received. It performs a token transfer (likely using `transferFrom`) from the caller to the contract and updates an internal storage variable (like mapping(bytes => mapping(address => uint256))) to track the amount of `token` held for the given `pubkey`. This function requires token approval beforehand. It emits the `IncentiveReceived` event upon successful receipt and recording of the incentive."
  },
  "IBGTIncentiveDistributor.claim": {
    "type": "external",
    "function_name": "claim(Claim[] calldata _claims) external",
    "analysis_result": "This external function allows users to claim their entitled rewards based on provided Merkle proofs. It accepts an array of `Claim` structs. Each `Claim` struct contains an `identifier` (linking to the reward distribution), the claimant's `account` address, the `amount` to claim, and the `merkleProof` needed to verify the claim against the distribution's Merkle root. The function iterates through the array, and for each claim, it performs several checks: verifies the Merkle proof using the stored `merkleRoot` associated with the `identifier`, checks if the current time is past the `activeAt` timestamp (which is calculated based on the reward update time and the `rewardClaimDelay`), and verifies that the amount hasn't been claimed before for this identifier and account (likely using a mapping like mapping(bytes32 => mapping(address => bool))). If all checks pass, it transfers the `amount` of the correct `token` (obtained from the reward metadata associated with the identifier) to the claimant's `account`. It updates storage to mark the claim as processed. This function is subject to the contract's pause state set by `setPauseState`. It emits the `RewardClaimed` event for each successfully processed claim."
  },
  "IBGTIncentiveDistributor.setPauseState": {
    "type": "external",
    "function_name": "setPauseState(bool state) external",
    "analysis_result": "This external function controls the pause state of the contract. It takes a boolean `state` as input, where `true` sets the contract to a paused state and `false` unpauses it. When paused, certain sensitive operations (like claiming rewards via the `claim` function) might be disabled. This function modifies a storage variable (likely a boolean `paused`) that tracks the contract's operational state. Access to this function is restricted by an access control mechanism, requiring the caller to possess the `PAUSER_ROLE`."
  },
  "IBGTIncentiveDistributor.updateRewardsMetadata": {
    "type": "external",
    "function_name": "updateRewardsMetadata(Distribution[] calldata _distributions) external",
    "analysis_result": "This external function is used to update or add metadata for reward distributions. It accepts an array of `Distribution` structs. Each `Distribution` struct contains an `identifier`, the validator's `pubkey`, the `token` address, the `merkleRoot` for the distribution, and a `proof` (likely a proof linking the pubkey to this distribution identifier). The function iterates through the array, and for each entry, it updates or creates the reward metadata associated with the `identifier` and `pubkey` in storage. It stores the `token`, `merkleRoot`, `proof`, and calculates the `activeAt` timestamp for the distribution based on the current block timestamp and the `rewardClaimDelay` (set by `setRewardClaimDelay`). A safety check is included to prevent updating the `token` address for an existing distribution, ensuring that an identifier always corresponds to the same token. This function is restricted by an access control mechanism, requiring the caller to have the `MANAGER_ROLE`. It emits the `RewardMetadataUpdated` event for each distribution whose metadata is updated."
  },
  "IDistributor.distributeFor": {
    "type": "external",
    "function_name": "distributeFor(uint64 nextTimestamp, uint64 proposerIndex, bytes calldata pubkey, bytes32[] calldata proposerIndexProof, bytes32[] calldata pubkeyProof)",
    "analysis_result": "This function is designed to distribute rewards to recipients based on beacon chain data. It takes the timestamp of the next beacon block ('nextTimestamp'), the proposer's validator index ('proposerIndex'), the proposer's validator public key ('pubkey'), and Merkle proofs ('proposerIndexProof', 'pubkeyProof') for the index and pubkey. The NatSpec indicates it's a permissionless function intended to verify these details against the EIP-4788 Beacon Roots contract using the provided proofs and timestamp. Upon successful verification, it would proceed to calculate or determine the reward amount and the receiver(s) based on internal logic or interaction with other contracts (like IBeraChef). It would then transfer the rewards and likely record the distribution to prevent double spending for that specific period/validator. If proofs are invalid or distribution has already occurred for this period/validator, it should revert (using errors inherited from IPOLErrors). It is expected to emit a 'Distributed' event upon successful distribution. As an interface, it does not contain implementation details, state variables, or direct calls, but an implementation would read the beacon state (likely via a precompile or wrapper), potentially read state regarding past distributions and receiver mappings, modify state to record distribution completion, and call transfer functions."
  },
  "IDistributor.beraChef": {
    "type": "external view",
    "function_name": "beraChef()",
    "analysis_result": "This is a simple view function that returns the address of the associated BeraChef contract (IBeraChef). Its purpose is to allow external callers to discover which BeraChef contract this distributor interacts with. As an interface, it does not contain implementation details or state variables, but an implementation would read a state variable storing the BeraChef contract address. It takes no parameters and returns an address."
  },
  "ERC165.supportsInterface": {
    "type": "external",
    "function_name": "supportsInterface(bytes4 interfaceId) external pure returns (bool)",
    "analysis_result": "Purpose: To query if a contract implements a specific interface identified by `interfaceId`. This function is part of the ERC-165 standard for interface detection. Input: `bytes4 interfaceId` - the identifier of the interface being queried. Output: `bool` - returns `true` if the contract implements the interface identified by `interfaceId` and `interfaceId` is not `0xffffffff`, and `false` otherwise. Logic: The function's logic, as defined by ERC-165, is to return `true` under the specified conditions and `false` otherwise. The actual implementation logic is not present in this interface definition but must adhere to this standard. State: The function is marked as `pure`, indicating that calling it is not allowed to modify the contract's state. Variables Used: It uses the input parameter `interfaceId`. No contract storage variables are defined or accessed in this interface definition."
  },
  "IBlockRewardController.baseRate": {
    "type": "external",
    "function_name": "baseRate() external view returns (uint256)",
    "analysis_result": "This is a view function returning a uint256 value. Its purpose is to provide read access to the constant base rate for BGT rewards per block. It reads the state variable intended to store the base rate. It does not take any parameters, modify state, or trigger events. It represents the base amount of BGT minted to a validator's operator."
  },
  "IBlockRewardController.rewardRate": {
    "type": "external",
    "function_name": "rewardRate() external view returns (uint256)",
    "analysis_result": "This is a view function returning a uint256 value. Its purpose is to provide read access to the unscaled reward rate parameter used in the BGT reward calculation per block. It reads the state variable intended to store the reward rate. It does not take any parameters, modify state, or trigger events. It is a component used in calculating the reward portion allocated to the distributor."
  },
  "IBlockRewardController.minBoostedRewardRate": {
    "type": "external",
    "function_name": "minBoostedRewardRate() external view returns (uint256)",
    "analysis_result": "This is a view function returning a uint256 value. Its purpose is to provide read access to the minimum boosted reward rate parameter. It reads the state variable intended to store the minimum boosted reward rate. It does not take any parameters, modify state, or trigger events. It likely represents a floor value in the boosted reward calculation."
  },
  "IBlockRewardController.boostMultiplier": {
    "type": "external",
    "function_name": "boostMultiplier() external view returns (uint256)",
    "analysis_result": "This is a view function returning a uint256 value. Its purpose is to provide read access to the boost multiplier parameter used in the BGT reward calculation formula. It reads the state variable intended to store the boost multiplier. It does not take any parameters, modify state, or trigger events. This parameter is described as determining the inflation cap in the reward formula."
  },
  "IBlockRewardController.rewardConvexity": {
    "type": "external",
    "function_name": "rewardConvexity() external view returns (int256)",
    "analysis_result": "This is a view function returning an int256 value. Its purpose is to provide read access to the reward convexity parameter used in the BGT reward calculation formula. It reads the state variable intended to store the reward convexity. It does not take any parameters, modify state, or trigger events. This parameter is described as determining how fast the reward function converges to its maximum."
  },
  "IBlockRewardController.computeReward": {
    "type": "external",
    "function_name": "computeReward(uint256 boostPower, uint256 _rewardRate, uint256 _boostMultiplier, int256 _rewardConvexity) external pure returns (uint256)",
    "analysis_result": "This is a pure function, meaning it does not read or modify state. It takes four parameters: `boostPower` (normalized boost), `_rewardRate`, `_boostMultiplier`, and `_rewardConvexity`. Its purpose is to calculate the reward amount based on these input parameters using a specific formula: `r := (1 + mul) * (1 - 1 / (1 + mul * boost^conv)) * rewardRate`. It returns the calculated reward amount as a uint256. The description mentions it returns 0 for boost == 0 even if conv == 0, implying internal logic handles this edge case and that the implementing contract enforces conv > 0."
  },
  "IBlockRewardController.getMaxBGTPerBlock": {
    "type": "external",
    "function_name": "getMaxBGTPerBlock() external view returns (uint256 amount)",
    "analysis_result": "This is a view function returning a uint256 value representing the maximum amount of BGT that can be minted in a single block. Its purpose is to expose this maximum value, potentially for use by other contracts like a BGT contract to calculate max burnable native tokens. It likely reads state variables such as `baseRate`, `rewardRate`, `boostMultiplier`, and `rewardConvexity` and potentially calls `computeReward` internally to determine the maximum possible reward under current parameters. It does not modify state or trigger events."
  },
  "IBlockRewardController.processRewards": {
    "type": "external",
    "function_name": "processRewards(bytes calldata pubkey, uint64 nextTimestamp, bool isReady) external returns (uint256)",
    "analysis_result": "This function processes rewards for a specific block. It takes the validator's `pubkey`, the `nextTimestamp` of the processed block, and an `isReady` flag as inputs. Its purpose is to mint BGT to the validator's operator (using `baseRate`) and, if `isReady` is true, to the distributor (calculated using reward parameters like `rewardRate`, `boostMultiplier`, `rewardConvexity`, potentially via `computeReward`). The interface specifies that this function can only be called by the designated distributor contract. It reads state variables for reward parameters (`baseRate`, `rewardRate`, etc.) and the distributor address. It implies an external call to a BGT contract to mint tokens to the operator and the distributor. It emits the `BlockRewardProcessed` event upon successful processing. It returns the amount of BGT minted to the distributor."
  },
  "IBlockRewardController.setBaseRate": {
    "type": "external",
    "function_name": "setBaseRate(uint256 _baseRate) external",
    "analysis_result": "This function sets the constant base reward rate for BGT. It takes a uint256 `_baseRate` as input. The interface specifies that this function can only be called by the contract's owner (governance address). Its purpose is to update the state variable that stores the base rate. It modifies the state variable intended for `baseRate`. It emits the `BaseRateChanged` event upon successful update, including the old and new rates."
  },
  "IBlockRewardController.setRewardRate": {
    "type": "external",
    "function_name": "setRewardRate(uint256 _rewardRate) external",
    "analysis_result": "This function sets the reward rate for BGT. It takes a uint256 `_rewardRate` as input. The interface specifies that this function can only be called by the contract's owner (governance address). Its purpose is to update the state variable that stores the reward rate. It modifies the state variable intended for `rewardRate`. It emits the `RewardRateChanged` event upon successful update, including the old and new rates."
  },
  "IBlockRewardController.setMinBoostedRewardRate": {
    "type": "external",
    "function_name": "setMinBoostedRewardRate(uint256 _minBoostedRewardRate) external",
    "analysis_result": "This function sets the minimum boosted reward rate for BGT. It takes a uint256 `_minBoostedRewardRate` as input. The interface specifies that this function can only be called by the contract's owner (governance address). Its purpose is to update the state variable that stores the minimum boosted reward rate. It modifies the state variable intended for `minBoostedRewardRate`. It emits the `MinBoostedRewardRateChanged` event upon successful update, including the old and new rates."
  },
  "IBlockRewardController.setBoostMultiplier": {
    "type": "external",
    "function_name": "setBoostMultiplier(uint256 _boostMultiplier) external",
    "analysis_result": "This function sets the boost multiplier parameter for the reward formula. It takes a uint256 `_boostMultiplier` as input. The interface specifies that this function can only be called by the contract's owner (governance address). Its purpose is to update the state variable that stores the boost multiplier. It modifies the state variable intended for `boostMultiplier`. It emits the `BoostMultiplierChanged` event upon successful update, including the old and new multipliers."
  },
  "IBlockRewardController.setRewardConvexity": {
    "type": "external",
    "function_name": "setRewardConvexity(int256 _rewardConvexity) external",
    "analysis_result": "This function sets the reward convexity parameter for the reward formula. It takes an int256 `_rewardConvexity` as input. The interface specifies that this function can only be called by the contract's owner (governance address). Its purpose is to update the state variable that stores the reward convexity. It modifies the state variable intended for `rewardConvexity`. It emits the `RewardConvexityChanged` event upon successful update, including the old and new convexity values."
  },
  "IBlockRewardController.setDistributor": {
    "type": "external",
    "function_name": "setDistributor(address _distributor) external",
    "analysis_result": "This function sets the address of the distributor contract that receives a portion of the minted BGT rewards. It takes an address `_distributor` as input. The interface specifies that this function can only be called by the contract's owner (governance address). Its purpose is to update the state variable that stores the distributor address. It modifies the state variable intended for the distributor address. It emits the `SetDistributor` event upon successful update, including the new distributor address."
  },
  "RewardVault_V2.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "Purpose: Disables the initializer to prevent it from being called more than once. Logic: Calls the `_disableInitializers()` function from the `Upgradeable` pattern. Storage Variables: None directly modified or checked by this constructor. Called Functions: `_disableInitializers()`. Emitted Events: None. Reverts: None."
  },
  "RewardVault_V2.initialize": {
    "type": "external",
    "function_name": "initialize(address _beaconDepositContract, address _bgt, address _distributor, address _stakingToken)",
    "analysis_result": "Purpose: Initializes the contract after deployment, setting up base contract variables and initial configuration. Logic: Initializes inherited contracts (`FactoryOwnable`, `PausableUpgradeable`, `ReentrancyGuardUpgradeable`, `StakingRewards`). Sets the `maxIncentiveTokensCount` to 2, the `distributor` address, and the `beaconDepositContract` address. Emits `DistributorSet` and `MaxIncentiveTokensCountUpdated` events. Storage Variables: `factoryOwner`, `_paused`, `_status` (from ReentrancyGuard), `stakeToken`, `rewardToken`, `rewardsDuration`, `maxIncentiveTokensCount`, `distributor`, `beaconDepositContract`. Called Functions: `__FactoryOwnable_init()`, `__Pausable_init()`, `__ReentrancyGuard_init()`, `__StakingRewards_init()`. Emitted Events: `DistributorSet`, `MaxIncentiveTokensCountUpdated`. Reverts: None (assuming inherited initializers don't revert on valid input)."
  },
  "RewardVault_V2.onlyDistributor": {
    "type": "modifier",
    "function_name": "onlyDistributor()",
    "analysis_result": "Purpose: Restricts function execution to the configured `distributor` address. Logic: Checks if `msg.sender` is equal to the stored `distributor` address. If not, it reverts with the `NotDistributor` error selector. Storage Variables: Reads `distributor`. Called Functions: None. Emitted Events: None. Reverts: `NotDistributor.selector.revertWith()`."
  },
  "RewardVault_V2.onlyOperatorOrUser": {
    "type": "modifier",
    "function_name": "onlyOperatorOrUser(address account)",
    "analysis_result": "Purpose: Restricts function execution to either the specified `account` or their registered `operator`. Logic: Checks if `msg.sender` is equal to `account`. If not, it then checks if `msg.sender` is the `operator` associated with `account` (read from `_operators` mapping). If neither is true, it reverts with the `NotOperator` error selector. Storage Variables: Reads `_operators`. Called Functions: None. Emitted Events: None. Reverts: `NotOperator.selector.revertWith()`."
  },
  "RewardVault_V2.checkSelfStakedBalance": {
    "type": "modifier",
    "function_name": "checkSelfStakedBalance(address account, uint256 amount)",
    "analysis_result": "Purpose: Ensures an account has sufficient self-staked balance before allowing an operation (specifically withdrawal). Logic: Calls the internal helper function `_checkSelfStakedBalance` with the provided `account` and `amount`. Storage Variables: None directly checked by the modifier, but the called function reads `_accountInfo` and `_delegateStake`. Called Functions: `_checkSelfStakedBalance()`. Emitted Events: None. Reverts: Reverts if `_checkSelfStakedBalance` reverts (i.e., with `InsufficientSelfStake`)."
  },
  "RewardVault_V2.onlyWhitelistedToken": {
    "type": "modifier",
    "function_name": "onlyWhitelistedToken(address token)",
    "analysis_result": "Purpose: Restricts function execution to a token that has been whitelisted as an incentive token. Logic: Checks if the `minIncentiveRate` for the given `token` in the `incentives` mapping is greater than 0. A `minIncentiveRate` of 0 signifies the token is not whitelisted. If it's not whitelisted, it reverts with the `TokenNotWhitelisted` error selector. Storage Variables: Reads `incentives`. Called Functions: None. Emitted Events: None. Reverts: `TokenNotWhitelisted.selector.revertWith()`."
  },
  "RewardVault_V2.setDistributor": {
    "type": "external",
    "function_name": "setDistributor(address _rewardDistribution)",
    "analysis_result": "Purpose: Sets the address of the distributor contract. Restricted to the factory owner. Logic: Checks if the provided `_rewardDistribution` address is not the zero address. Updates the `distributor` storage variable. Emits the `DistributorSet` event. Storage Variables: Writes `distributor`. Called Functions: None. Emitted Events: `DistributorSet`. Reverts: `ZeroAddress.selector.revertWith()` if `_rewardDistribution` is zero. Inherited from `FactoryOwnable` with `onlyFactoryOwner`."
  },
  "RewardVault_V2.notifyRewardAmount": {
    "type": "external",
    "function_name": "notifyRewardAmount(bytes calldata pubkey, uint256 reward)",
    "analysis_result": "Purpose: Notifies the contract about a new amount of BGT rewards to be distributed. Restricted to the distributor. Logic: Calls the internal `_notifyRewardAmount` function from the `StakingRewards` base contract to update the reward amount and rate for BGT. Then calls the internal `_processIncentives` function to potentially distribute other whitelisted incentive tokens associated with this BGT emission event for the given validator pubkey. Storage Variables: Modifies base contract storage related to rewards (e.g., `rewardRate`, `lastUpdateTime`, `rewardPerTokenStored`, `undistributedRewards`). `_processIncentives` reads `whitelistedTokens` and `incentives`. Called Functions: `_notifyRewardAmount()`, `_processIncentives()`. Emitted Events: Emits events from `_notifyRewardAmount` (e.g., `RewardAdded`). `_processIncentives` emits `IncentivesProcessed`, `IncentivesProcessFailed`, `BGTBoosterIncentivesProcessed`, `BGTBoosterIncentivesProcessFailed`. Reverts: Reverts if called by an address other than `distributor` (due to `onlyDistributor`). `_notifyRewardAmount` may revert if reward exceeds balance or causes overflow in reward rate calculation. `_processIncentives` might revert if allowance or token transfers fail in a way that isn't caught by `trySafeTransfer` or the `call` checks."
  },
  "RewardVault_V2.recoverERC20": {
    "type": "external",
    "function_name": "recoverERC20(address tokenAddress, uint256 tokenAmount)",
    "analysis_result": "Purpose: Allows the factory owner to recover inadvertently sent ERC20 tokens from the contract. Logic: Checks that the token is not the staking token (`stakeToken`) and not a whitelisted incentive token (by checking if `minIncentiveRate` is 0 for the token). Transfers the specified `tokenAmount` of `tokenAddress` to the factory owner using `safeTransfer`. Emits the `Recovered` event. Storage Variables: Reads `stakeToken`, `incentives`. Called Functions: `IERC20.safeTransfer()`. Emitted Events: `Recovered`. Reverts: `CannotRecoverStakingToken.selector.revertWith()` if trying to recover the staking token. `CannotRecoverIncentiveToken.selector.revertWith()` if trying to recover a whitelisted incentive token. Inherited from `FactoryOwnable` with `onlyFactoryOwner`."
  },
  "RewardVault_V2.setRewardsDuration": {
    "type": "external",
    "function_name": "setRewardsDuration(uint256 _rewardsDuration)",
    "analysis_result": "Purpose: Sets the duration over which the BGT rewards are distributed. Restricted to the factory owner. Logic: Calls the internal `_setRewardsDuration` function from the `StakingRewards` base contract to update the `rewardsDuration`. Storage Variables: Writes `rewardsDuration`. Called Functions: `_setRewardsDuration()`. Emitted Events: Emits events from `_setRewardsDuration` (e.g., `RewardsDurationUpdated`). Reverts: Reverts if called by an address other than the factory owner (due to `onlyFactoryOwner`). `_setRewardsDuration` reverts if the new duration is zero or if there are undistributed rewards from the previous duration."
  },
  "RewardVault_V2.whitelistIncentiveToken": {
    "type": "external",
    "function_name": "whitelistIncentiveToken(address token, uint256 minIncentiveRate, address manager)",
    "analysis_result": "Purpose: Adds a new token to the list of whitelisted incentive tokens that can be distributed alongside BGT rewards. Restricted to the factory owner. Logic: Validates `minIncentiveRate` is not zero and not greater than `MAX_INCENTIVE_RATE`. Validates `token` and `manager` addresses are not zero. Checks if the `whitelistedTokens` list has reached the `maxIncentiveTokensCount` or if the token is already whitelisted (by checking `incentives[token].minIncentiveRate != 0`). If valid and not already whitelisted/limit not reached, it adds the `token` to the `whitelistedTokens` array, sets the `incentiveRate`, `minIncentiveRate`, and `manager` in the `incentives` mapping. Emits the `IncentiveTokenWhitelisted` event. Storage Variables: Writes `incentives`, `whitelistedTokens`. Reads `MAX_INCENTIVE_RATE`, `whitelistedTokens`, `maxIncentiveTokensCount`, `incentives`. Called Functions: None. Emitted Events: `IncentiveTokenWhitelisted`. Reverts: `MinIncentiveRateIsZero.selector.revertWith()` if `minIncentiveRate` is 0. `IncentiveRateTooHigh.selector.revertWith()` if `minIncentiveRate` exceeds `MAX_INCENTIVE_RATE`. `ZeroAddress.selector.revertWith()` if `token` or `manager` is zero. `TokenAlreadyWhitelistedOrLimitReached.selector.revertWith()` if the token is already whitelisted or the maximum count is reached. Inherited from `FactoryOwnable` with `onlyFactoryOwner`."
  },
  "RewardVault_V2.removeIncentiveToken": {
    "type": "external",
    "function_name": "removeIncentiveToken(address token)",
    "analysis_result": "Purpose: Removes a token from the list of whitelisted incentive tokens. Restricted to the factory vault manager. Logic: Uses the `onlyWhitelistedToken` modifier to ensure the token is currently whitelisted. Deletes the entry for the `token` from the `incentives` mapping. Calls the internal `_deleteWhitelistedTokenFromList` function to remove the token from the `whitelistedTokens` array. Emits the `IncentiveTokenRemoved` event. Storage Variables: Writes `incentives`, `whitelistedTokens`. Reads `incentives` (via modifier). Called Functions: `_deleteWhitelistedTokenFromList()`. Emitted Events: `IncentiveTokenRemoved`. Reverts: Reverts if the token is not whitelisted (due to `onlyWhitelistedToken`). Inherited from `FactoryOwnable` with `onlyFactoryVaultManager`."
  },
  "RewardVault_V2.updateIncentiveManager": {
    "type": "external",
    "function_name": "updateIncentiveManager(address token, address newManager)",
    "analysis_result": "Purpose: Updates the address of the manager allowed to add incentives for a specific whitelisted token. Restricted to the factory owner. Logic: Uses the `onlyWhitelistedToken` modifier to ensure the token is whitelisted. Checks that the `newManager` address is not zero. Updates the `manager` field for the `token` in the `incentives` mapping. Emits the `IncentiveManagerChanged` event, including the old manager address. Storage Variables: Writes `incentives`. Reads `incentives` (via modifier). Called Functions: None. Emitted Events: `IncentiveManagerChanged`. Reverts: Reverts if the token is not whitelisted (due to `onlyWhitelistedToken`). `ZeroAddress.selector.revertWith()` if `newManager` is zero. Inherited from `FactoryOwnable` with `onlyFactoryOwner`."
  },
  "RewardVault_V2.setMaxIncentiveTokensCount": {
    "type": "external",
    "function_name": "setMaxIncentiveTokensCount(uint8 _maxIncentiveTokensCount)",
    "analysis_result": "Purpose: Sets the maximum number of incentive tokens that can be whitelisted simultaneously. Restricted to the factory owner. Logic: Checks that the proposed `_maxIncentiveTokensCount` is not less than the current number of whitelisted tokens (read from `whitelistedTokens.length`). Updates the `maxIncentiveTokensCount` storage variable. Emits the `MaxIncentiveTokensCountUpdated` event. Storage Variables: Writes `maxIncentiveTokensCount`. Reads `whitelistedTokens`. Called Functions: None. Emitted Events: `MaxIncentiveTokensCountUpdated`. Reverts: `InvalidMaxIncentiveTokensCount.selector.revertWith()` if `_maxIncentiveTokensCount` is less than the current count. Inherited from `FactoryOwnable` with `onlyFactoryOwner`."
  },
  "RewardVault_V2.pause": {
    "type": "external",
    "function_name": "pause()",
    "analysis_result": "Purpose: Pauses the contract, preventing state-changing operations protected by `whenNotPaused`. Restricted to the factory vault pauser. Logic: Calls the internal `_pause()` function from the `PausableUpgradeable` base contract. Storage Variables: Writes `_paused`. Called Functions: `_pause()`. Emitted Events: Emits events from `_pause` (e.g., `Paused`). Reverts: Reverts if called by an address other than the factory vault pauser (due to `onlyFactoryVaultPauser`). Reverts if the contract is already paused."
  },
  "RewardVault_V2.unpause": {
    "type": "external",
    "function_name": "unpause()",
    "analysis_result": "Purpose: Unpauses the contract, allowing state-changing operations protected by `whenNotPaused`. Restricted to the factory vault manager. Logic: Calls the internal `_unpause()` function from the `PausableUpgradeable` base contract. Storage Variables: Writes `_paused`. Called Functions: `_unpause()`. Emitted Events: Emits events from `_unpause` (e.g., `Unpaused`). Reverts: Reverts if called by an address other than the factory vault manager (due to `onlyFactoryVaultManager`). Reverts if the contract is already unpaused."
  },
  "RewardVault_V2.operator": {
    "type": "external",
    "function_name": "operator(address account)",
    "analysis_result": "Purpose: Gets the registered operator address for a given account. Logic: Returns the value associated with `account` in the `_operators` mapping. Storage Variables: Reads `_operators`. Called Functions: None. Emitted Events: None. Reverts: None."
  },
  "RewardVault_V2.getWhitelistedTokensCount": {
    "type": "external",
    "function_name": "getWhitelistedTokensCount()",
    "analysis_result": "Purpose: Gets the current number of whitelisted incentive tokens. Logic: Returns the `length` of the `whitelistedTokens` array. Storage Variables: Reads `whitelistedTokens`. Called Functions: None. Emitted Events: None. Reverts: None."
  },
  "RewardVault_V2.getWhitelistedTokens": {
    "type": "public",
    "function_name": "getWhitelistedTokens()",
    "analysis_result": "Purpose: Gets the list of all whitelisted incentive tokens. Logic: Returns the entire `whitelistedTokens` array. Storage Variables: Reads `whitelistedTokens`. Called Functions: None. Emitted Events: None. Reverts: None."
  },
  "RewardVault_V2.getTotalDelegateStaked": {
    "type": "external",
    "function_name": "getTotalDelegateStaked(address account)",
    "analysis_result": "Purpose: Gets the total amount staked by delegates *for* a given account. Logic: Returns the `delegateTotalStaked` value from the `DelegateStake` struct associated with `account` in the `_delegateStake` mapping. Storage Variables: Reads `_delegateStake`. Called Functions: None. Emitted Events: None. Reverts: None."
  },
  "RewardVault_V2.getDelegateStake": {
    "type": "external",
    "function_name": "getDelegateStake(address account, address delegate)",
    "analysis_result": "Purpose: Gets the amount staked by a specific `delegate` *for* a specific `account`. Logic: Returns the value associated with `delegate` in the `stakedByDelegate` mapping within the `DelegateStake` struct for `account` in the `_delegateStake` mapping. Storage Variables: Reads `_delegateStake`. Called Functions: None. Emitted Events: None. Reverts: None."
  },
  "RewardVault_V2.stake": {
    "type": "external",
    "function_name": "stake(uint256 amount)",
    "analysis_result": "Purpose: Allows a user to stake `amount` of the staking token (`stakeToken`). Logic: Uses the `nonReentrant` and `whenNotPaused` modifiers for safety checks. Calls the internal `_stake` function from the `StakingRewards` base contract with `msg.sender` as the account and the specified `amount`. This handles the token transfer into the vault and updates the staking balance for `msg.sender`. Storage Variables: Modifies base contract storage related to staking (`_accountInfo`, `totalSupply`). Called Functions: `_stake()`. Emitted Events: Emits events from `_stake` (e.g., `Staked`). Reverts: Reverts if reentrant (due to `nonReentrant`). Reverts if paused (due to `whenNotPaused`). `_stake` will revert if the token transfer fails or the amount is zero."
  },
  "RewardVault_V2.delegateStake": {
    "type": "external",
    "function_name": "delegateStake(address account, uint256 amount)",
    "analysis_result": "Purpose: Allows a delegate (`msg.sender`) to stake `amount` of the staking token on behalf of another `account`. Logic: Uses the `nonReentrant` and `whenNotPaused` modifiers. Checks that `msg.sender` is not the same as `account` (a delegate cannot stake for themselves using this function). Calls the internal `_stake` function from the `StakingRewards` base contract with the target `account` and the specified `amount`. This transfers tokens into the vault and updates the staking balance for the `account`. It then updates the `delegateTotalStaked` for the `account` and the `stakedByDelegate` amount for `msg.sender` within the `_delegateStake` mapping for the `account`. Uses `unchecked` for stake amount updates, relying on the total supply increment in `_stake` for bounds check. Emits the `DelegateStaked` event. Storage Variables: Writes `_delegateStake`, `_accountInfo`, `totalSupply`. Called Functions: `_stake()`. Emitted Events: `DelegateStaked`, plus events from `_stake` (e.g., `Staked`). Reverts: `NotDelegate.selector.revertWith()` if `msg.sender` is the same as `account`. Reverts if reentrant (due to `nonReentrant`). Reverts if paused (due to `whenNotPaused`). `_stake` may revert. Potential for delegate stake values to exceed total if `_stake` somehow failed after delegate stake updates, though this order is not the case here."
  },
  "RewardVault_V2.withdraw": {
    "type": "external",
    "function_name": "withdraw(uint256 amount)",
    "analysis_result": "Purpose: Allows a user to withdraw `amount` of their *self-staked* staking tokens. Logic: Uses the `nonReentrant` modifier. Uses the `checkSelfStakedBalance` modifier to ensure the user has sufficient self-staked balance for the withdrawal amount. Calls the internal `_withdraw` function from the `StakingRewards` base contract with `msg.sender` as the account and the specified `amount`. This updates the staking balance and handles the token transfer out of the vault. Storage Variables: Modifies base contract storage related to staking (`_accountInfo`, `totalSupply`). Reads `_accountInfo` and `_delegateStake` via the modifier. Called Functions: `_checkSelfStakedBalance()` (via modifier), `_withdraw()`. Emitted Events: Emits events from `_withdraw` (e.g., `Withdrawn`). Reverts: Reverts if reentrant (due to `nonReentrant`). Reverts if self-staked balance is insufficient (due to `checkSelfStakedBalance`). `_withdraw` will revert if the token transfer out fails or the amount is zero/exceeds total balance."
  },
  "RewardVault_V2.delegateWithdraw": {
    "type": "external",
    "function_name": "delegateWithdraw(address account, uint256 amount)",
    "analysis_result": "Purpose: Allows a delegate (`msg.sender`) to withdraw `amount` of staking tokens they previously staked on behalf of an `account`. Logic: Uses the `nonReentrant` modifier. Checks that `msg.sender` is not the same as `account` (a delegate cannot withdraw their own self-stake via this function). Updates the `stakedByDelegate` amount for `msg.sender` within the `DelegateStake` struct for the `account` in the `_delegateStake` mapping, ensuring the delegate is not withdrawing more than they staked. Updates the `delegateTotalStaked` for the `account`. Uses `unchecked` for the subtractions, relying on the balance check and `>= amount` check. Calls the internal `_withdraw` function from the `StakingRewards` base contract with the target `account` and the specified `amount`. This updates the staking balance for the `account` and handles the token transfer out of the vault. Emits the `DelegateWithdrawn` event. Storage Variables: Writes `_delegateStake`, `_accountInfo`, `totalSupply`. Called Functions: `_withdraw()`. Emitted Events: `DelegateWithdrawn`, plus events from `_withdraw` (e.g., `Withdrawn`). Reverts: `NotDelegate.selector.revertWith()` if `msg.sender` is the same as `account`. `InsufficientDelegateStake.selector.revertWith()` if `msg.sender` tries to withdraw more than they staked for the account. Reverts if reentrant (due to `nonReentrant`). `_withdraw` may revert."
  },
  "RewardVault_V2.getReward": {
    "type": "external",
    "function_name": "getReward(address account, address recipient)",
    "analysis_result": "Purpose: Allows an `account` or their `operator` to claim earned BGT rewards, sending them to a specified `recipient`. Logic: Uses the `nonReentrant` modifier. Uses the `onlyOperatorOrUser` modifier to restrict calls to the `account` or their `operator`. Calls the internal `_getReward` function from the `StakingRewards` base contract with the target `account` and the specified `recipient`. This calculates earned rewards, updates accounting, and transfers the BGT. Storage Variables: Modifies base contract storage related to rewards and earnings (`_accountInfo`, `userRewardPerTokenPaid`, `rewards`). Called Functions: `_getReward()`. Emitted Events: Emits events from `_getReward` (e.g., `RewardPaid`). Reverts: Reverts if reentrant (due to `nonReentrant`). Reverts if called by an address other than the `account` or their `operator` (due to `onlyOperatorOrUser`). `_getReward` will revert if the BGT transfer fails or the earned amount is zero."
  },
  "RewardVault_V2.exit": {
    "type": "external",
    "function_name": "exit(address recipient)",
    "analysis_result": "Purpose: Allows a user (`msg.sender`) to withdraw all of their *self-staked* tokens and claim their earned BGT rewards in a single transaction, sending the BGT to a specified `recipient`. Logic: Uses the `nonReentrant` modifier. Calculates the user's self-staked amount by subtracting their total delegate-staked amount (read from `_delegateStake`) from their total staked balance (read from `_accountInfo`). Calls the internal `_withdraw` function to withdraw this calculated self-staked amount. Calls the internal `_getReward` function to claim earned BGT, sending it to the `recipient`. Storage Variables: Reads `_accountInfo`, `_delegateStake`. Writes `_accountInfo`, `totalSupply` (via `_withdraw`), `userRewardPerTokenPaid`, `rewards` (via `_getReward`). Called Functions: `_withdraw()`, `_getReward()`. Emitted Events: Emits events from `_withdraw` (e.g., `Withdrawn`) and `_getReward` (e.g., `RewardPaid`). Reverts: Reverts if reentrant (due to `nonReentrant`). `_withdraw` or `_getReward` may revert."
  },
  "RewardVault_V2.setOperator": {
    "type": "external",
    "function_name": "setOperator(address _operator)",
    "analysis_result": "Purpose: Allows a user (`msg.sender`) to set or update the address of their designated operator. The operator can perform `getReward` on their behalf. Logic: Updates the `_operators` mapping for `msg.sender` with the provided `_operator` address. Emits the `OperatorSet` event. Storage Variables: Writes `_operators`. Called Functions: None. Emitted Events: `OperatorSet`. Reverts: None."
  },
  "RewardVault_V2.addIncentive": {
    "type": "external",
    "function_name": "addIncentive(address token, uint256 amount, uint256 incentiveRate)",
    "analysis_result": "Purpose: Allows the manager of a whitelisted incentive token to add more tokens to the vault and potentially update the incentive rate. Logic: Uses the `nonReentrant` modifier. Uses the `onlyWhitelistedToken` modifier to ensure the `token` is valid for this operation. Checks if the provided `incentiveRate` exceeds `MAX_INCENTIVE_RATE`. Checks if `msg.sender` is the registered `manager` for the `token` (read from `incentives`). Checks if the provided `amount` is less than the `minIncentiveRate` (a spam prevention measure). Transfers the `amount` of `token` from `msg.sender` to the contract using `safeTransferFrom`. Updates the `amountRemaining` for the `token` in the `incentives` mapping. Conditionally updates the `incentiveRate` based on whether `amountRemainingBefore` was zero or if the new `incentiveRate` is higher and the added `amount` is sufficient to maintain the potential BGT incentivized by the previous remaining amount at the new rate. Emits the `IncentiveAdded` event. Storage Variables: Reads `incentives`, `MAX_INCENTIVE_RATE`. Writes `incentives`. Called Functions: `IERC20.safeTransferFrom()`, `FixedPointMathLib.mulDiv()`, `FixedPointMathLib.min()`. Emitted Events: `IncentiveAdded`. Reverts: Reverts if reentrant (due to `nonReentrant`). Reverts if the token is not whitelisted (due to `onlyWhitelistedToken`). `IncentiveRateTooHigh.selector.revertWith()` if `incentiveRate` exceeds `MAX_INCENTIVE_RATE`. `NotIncentiveManager.selector.revertWith()` if `msg.sender` is not the token manager. `AmountLessThanMinIncentiveRate.selector.revertWith()` if `amount` is less than `minIncentiveRate`. `safeTransferFrom` may revert."
  },
  "RewardVault_V2._checkSelfStakedBalance": {
    "type": "internal",
    "function_name": "_checkSelfStakedBalance(address account, uint256 amount)",
    "analysis_result": "Purpose: Internal helper to check if a user's self-staked balance is sufficient for a given `amount`. Logic: Calculates the self-staked amount for the `account` by subtracting the `delegateTotalStaked` (read from `_delegateStake`) from the total staked `balance` (read from `_accountInfo`). Uses `unchecked` for the subtraction, assuming total balance is always >= delegate staked amount. Checks if the calculated `selfStaked` amount is less than the requested `amount`. If so, it reverts. Storage Variables: Reads `_accountInfo`, `_delegateStake`. Called Functions: None. Emitted Events: None. Reverts: `InsufficientSelfStake.selector.revertWith()` if `selfStaked` is less than `amount`."
  },
  "RewardVault_V2._safeTransferRewardToken": {
    "type": "internal",
    "function_name": "_safeTransferRewardToken(address to, uint256 amount)",
    "analysis_result": "Purpose: Internal function to transfer BGT rewards, used by the `StakingRewards` base contract's `_getReward` function. Logic: Overrides the base contract's transfer logic. Transfers `amount` of `rewardToken` (BGT) from the `distributor` address to the specified `to` address using `safeTransferFrom`. Requires that the `distributor` has granted allowance to this contract. Storage Variables: Reads `rewardToken`, `distributor`. Called Functions: `SafeERC20.safeTransferFrom()`. Emitted Events: None directly. Reverts: `safeTransferFrom` will revert if the transfer fails (e.g., insufficient balance, insufficient allowance)."
  },
  "RewardVault_V2._checkRewardSolvency": {
    "type": "internal",
    "function_name": "_checkRewardSolvency()",
    "analysis_result": "Purpose: Internal function to check if the contract has enough allowance from the distributor to cover the undistributed BGT rewards. Used by the `StakingRewards` base contract's `_notifyRewardAmount`. Logic: Overrides the base contract's check. Calculates the required allowance based on `undistributedRewards`. Gets the actual `allowance` granted by the `distributor` to this contract for the `rewardToken`. Checks if the required allowance is greater than the actual `allowance`. If so, it reverts. Storage Variables: Reads `undistributedRewards`, `rewardToken`, `distributor`. Called Functions: `IERC20.allowance()`. Emitted Events: None. Reverts: `InsolventReward.selector.revertWith()` if the required allowance exceeds the actual allowance."
  },
  "RewardVault_V2._processIncentives": {
    "type": "internal",
    "function_name": "_processIncentives(bytes calldata pubkey, uint256 bgtEmitted)",
    "analysis_result": "Purpose: Internal function triggered after BGT emission (`notifyRewardAmount`) to distribute whitelisted incentive tokens proportionally. Logic: Gets the operator address for the given `pubkey` from the `beaconDepositContract`. Gets the `beraChef` and `bgtIncentiveDistributor` contract addresses from the `distributor`. Iterates through the `whitelistedTokens` list. For each token, calculates the potential incentive `amount` based on `bgtEmitted` and the token's `incentiveRate` (read from `incentives`). Caps the `amount` at the `amountRemaining` for that token. If the capped `amount` is greater than zero, calculates the `validatorShare` using the `beraChef`. Transfers the `validatorShare` to the validator's `_operator` address using `trySafeTransfer`. If successful, updates `amountRemaining` and emits `IncentivesProcessed`. If `trySafeTransfer` fails, emits `IncentivesProcessFailed`. If there's a remaining `amount` after validator share (intended for BGT boosters), it attempts to `approve` the `bgtIncentiveDistributor` to spend the `amount` of the incentive token, then attempts to call `receiveIncentive` on the `bgtIncentiveDistributor`. Both calls use a `SAFE_GAS_LIMIT`. If both calls succeed, updates `amountRemaining` and emits `BGTBoosterIncentivesProcessed`. If either call fails, it attempts to reset the allowance to zero (for tokens like USDT) and emits `BGTBoosterIncentivesProcessFailed`. Updates the `amountRemaining` for the token in the `incentives` mapping after processing. Uses `unchecked` for the loop index and amount subtractions within the loop. Storage Variables: Reads `beaconDepositContract`, `distributor`, `whitelistedTokens`, `incentives`. Writes `incentives`. Called Functions: `IBeaconDeposit.getOperator()`, `IDistributor.beraChef()`, `IBGTIncentiveDistributor.receiveIncentive()` (via low-level call), `IERC20.approve()` (via low-level call), `SafeERC20.trySafeTransfer()`, `FixedPointMathLib.mulDiv()`, `FixedPointMathLib.min()`, `IBeraChef.getValidatorIncentiveTokenShare()`, `Utils.getBGTIncentiveDistributor()`. Emitted Events: `IncentivesProcessed`, `IncentivesProcessFailed`, `BGTBoosterIncentivesProcessed`, `BGTBoosterIncentivesProcessFailed`. Reverts: None directly, but relied-upon external calls or low-level calls might revert the transaction."
  },
  "RewardVault_V2._deleteWhitelistedTokenFromList": {
    "type": "internal",
    "function_name": "_deleteWhitelistedTokenFromList(address token)",
    "analysis_result": "Purpose: Internal helper to remove a token address from the `whitelistedTokens` array. Logic: Iterates through the `whitelistedTokens` array. Finds the index of the `token` to be removed. Replaces the element at that index with the last element in the array. Reduces the array length by one using `pop()`. Uses `unchecked` for the loop index. Returns after finding and removing the token. Assumes the token exists in the list (checked by the `onlyWhitelistedToken` modifier in calling functions). Storage Variables: Writes `whitelistedTokens`. Reads `whitelistedTokens`. Called Functions: `Array.pop()`. Emitted Events: None. Reverts: None directly. Accessing `whitelistedTokens[activeTokens - 1]` could potentially cause a panic if the array was empty before the loop, but the check `onlyWhitelistedToken` should prevent this case."
  },
  "SSZ.validatorPubkeyHashTreeRoot": {
    "type": "internal view",
    "function_name": "validatorPubkeyHashTreeRoot(bytes memory pubkey)",
    "analysis_result": "This function computes the SSZ hash tree root for a validator public key. It first checks if the provided `pubkey` has the expected length defined by the `VALIDATOR_PUBKEY_LENGTH` constant (48 bytes). If the length is incorrect, it reverts using the `InvalidValidatorPubkeyLength` error's selector. If the length is correct, it uses inline assembly (`assembly(\"memory-safe\")`) to call the SHA256 precompile contract at the address specified by the `SHA256` constant (0x02). The precompile is called with the memory address of the public key data and a size of 64 bytes (0x40), expecting a 32-byte (0x20) result. The function checks if the `staticcall` was successful; if not (result is 0), it reverts. The 32-byte result from the precompile (which is the SHA256 hash of the pubkey) is loaded from memory location 0x00 and returned as a `bytes32` hash tree root. It uses the constants `VALIDATOR_PUBKEY_LENGTH` and `SHA256`, and the error `InvalidValidatorPubkeyLength`."
  },
  "SSZ.addressHashTreeRoot": {
    "type": "internal pure",
    "function_name": "addressHashTreeRoot(address v)",
    "analysis_result": "This function computes the SSZ hash tree root for an Ethereum address. According to SSZ simple basic type serialization rules for fixed-size types, an address (20 bytes) is serialized and then zero-padded to 32 bytes for hashing. This function achieves this directly by casting the 20-byte address to a `bytes20` and then to a `bytes32`. This effectively zero-pads the address to the right (most significant bytes) within the 32-byte `bytes32` container, which aligns with the SSZ standard for basic types when placed in a Merkle tree. It is a `pure` function as it does not read from or write to storage and its result depends only on its input parameters."
  },
  "SSZ.uint64HashTreeRoot": {
    "type": "internal pure",
    "function_name": "uint64HashTreeRoot(uint64 v)",
    "analysis_result": "This function computes the SSZ hash tree root for a `uint64` value. SSZ basic types are typically serialized in little-endian format and padded to 32 bytes for hashing within a Merkle tree. This function performs a manual byte-swapping operation on the 8-byte `uint64` value `v` to convert it from the typical big-endian representation used by the EVM to little-endian. It performs byte swaps in stages (pairs, quads, octets). The resulting little-endian `uint64` value is then cast to `uint256` and left-shifted by 192 bits (`<< 192`), effectively placing the 8-byte little-endian value in the *least significant* 8 bytes of a 32-byte word and zero-padding the most significant 24 bytes. This 32-byte value is then cast to `bytes32` and returned as the hash tree root. It is a `pure` function as it does not read from or write to storage and its result depends only on its input parameters."
  },
  "SSZ.verifyProof": {
    "type": "internal view",
    "function_name": "verifyProof(bytes32[] calldata proof, bytes32 root, bytes32 leaf, uint256 index)",
    "analysis_result": "This function verifies a generalized Merkle proof against a given root and leaf. It takes a Merkle `proof` (an array of hashes), the expected `root` hash, the `leaf` hash being proven, and the `index` of the leaf in the tree. It uses inline assembly (`assembly(\"memory-safe\")`) to efficiently process the proof and call the SHA256 precompile. The logic iterates through the `proof` array. In each iteration, it determines the correct order of hashing the current `leaf` with the current `proof` element based on the `index`'s least significant bit (`index & 1`). If the bit is 1, the `proof` element is hashed before the `leaf`; otherwise, the `leaf` is hashed before the `proof` element. The two elements are concatenated in scratch space (memory addresses 0x00-0x3f) in the determined order and the SHA256 precompile (at address `SHA256`, 0x02) is called on the 64 bytes (0x40) in scratch space, expecting a 32-byte (0x20) result. The result is stored back into the `leaf` variable for the next iteration. The `index` is right-shifted by 1 (`index := shr(1, index)`) in each step, moving to the next level of the tree. The assembly checks if the SHA256 precompile call is successful (`eq(result, 0)`) and reverts if not. After processing all proof elements, the loop terminates. It then checks if the `index` has been reduced to 1. If `index` is not 1 at the end, it means either too many proof items were provided for the given index (`index > 1`, checked with `gt(sub(index, 1), 0)`, leading to `BranchHasMissingItem` revert) or not enough (the loop would have finished but index wouldn't be 1, also leading to `BranchHasMissingItem`). If the number of items was correct, the final computed `leaf` hash is compared with the provided `root`. The function returns `true` if they match (`eq(leaf, root)`) and the proof is valid, and `false` otherwise. It uses the constant `SHA256` and the errors `BranchHasExtraItem` and `BranchHasMissingItem`."
  },
  "BeaconRoots.isParentBlockRootAt": {
    "type": "internal",
    "function_name": "isParentBlockRootAt(uint64 ts) internal view returns (bool success)",
    "analysis_result": "This function checks if a parent block root exists at a given timestamp 'ts' by calling the EIP-4788 Beacon Roots precompile located at the constant address 'ADDRESS'. It uses inline assembly (`memory-safe`). The input timestamp 'ts' is stored in memory at offset 0. A `staticcall` is then made to the precompile 'ADDRESS' with input data from memory offset 0 of size 32 bytes (corresponding to the stored uint64 timestamp) and expecting output data of size 32 bytes to be written to memory offset 0. The boolean return value 'success' indicates whether the `staticcall` to the precompile did not revert (meaning the precompile executed successfully). The function uses the input variable 'ts' and the constant 'ADDRESS'. It does not directly modify or check any storage variables of the library itself; its interaction is with the EIP-4788 precompile."
  },
  "BeaconRoots.getParentBlockRootAt": {
    "type": "internal",
    "function_name": "getParentBlockRootAt(uint64 ts) internal view returns (bytes32 root)",
    "analysis_result": "This function retrieves the 32-byte parent block root for a given timestamp 'ts' from the EIP-4788 Beacon Roots precompile at the constant address 'ADDRESS'. It uses inline assembly (`memory-safe`). The input timestamp 'ts' is stored in memory at offset 0. A `staticcall` is performed to the precompile 'ADDRESS' with input data from memory offset 0 (32 bytes) and expecting output data (the 32-byte root) to be written to memory offset 0. The boolean result of the `staticcall` is checked using `iszero(success)`. If `staticcall` failed (returned 0, likely indicating the precompile reverted because the root was not found for the given timestamp or the timestamp was invalid/too old), the function attempts to revert. The assembly writes the `RootNotFound()` error selector (0x3033b0ff) to memory at offset 0, but the `revert` instruction is called with offset 28 (0x1c) and size 4 (0x04), which is an unusual pattern for reverting with an error selector. If `staticcall` succeeded (returned non-zero), the function loads the 32 bytes from memory at offset 0 (where the precompile wrote the root) into the `root` return variable. The function uses the input variable 'ts', the constant 'ADDRESS', the `RootNotFound` error selector, and the assembly variables `success` and `root`. It does not directly modify or check any storage variables of the library; its interaction is with the EIP-4788 precompile."
  },
  "Utils.revertWith": [
    {
      "type": "internal pure",
      "function_name": "revertWith(bytes4 selector)",
      "analysis_result": "This is an internal pure helper function designed to revert execution immediately using a specific 4-byte error selector. It takes one parameter: `selector` (bytes4), representing the function selector of a custom error. The function uses Yul assembly. It stores the provided `selector` in memory at offset 0 (`mstore(0, selector)`) and then executes a revert operation (`revert(0, 0x04)`), which reverts the transaction and returns the 4 bytes stored at memory location 0 as the revert reason. No state variables are accessed or modified. It doesn't call other Solidity functions directly, but uses the assembly `revert` instruction."
    },
    {
      "type": "internal pure",
      "function_name": "revertWith(bytes4 selector, address addr)",
      "analysis_result": "This is an internal pure helper function to revert execution with a custom error selector and a single address argument. It takes two parameters: `selector` (bytes4) and `addr` (address). It uses Yul assembly to prepare the revert data. It stores the `selector` at memory offset 0 (`mstore(0, selector)`) and the `addr` at memory offset 0x04 (`mstore(0x04, addr)`), immediately following the selector. It then reverts using `revert(0, 0x24)`, indicating the data starts at offset 0 and has a length of 0x24 bytes (4 bytes for the selector + 32 bytes for the address). No state variables are accessed or modified. It doesn't call other Solidity functions directly, but uses the assembly `revert` instruction."
    },
    {
      "type": "internal pure",
      "function_name": "revertWith(bytes4 selector, uint256 amount)",
      "analysis_result": "This is an internal pure helper function to revert execution with a custom error selector and a single uint256 argument. It takes two parameters: `selector` (bytes4) and `amount` (uint256). It uses Yul assembly to prepare the revert data. It stores the `selector` at memory offset 0 (`mstore(0, selector)`) and the `amount` at memory offset 0x04 (`mstore(0x04, amount)`). It then reverts using `revert(0, 0x24)`, indicating the data starts at offset 0 and has a length of 0x24 bytes (4 bytes for the selector + 32 bytes for the uint256). No state variables are accessed or modified. It doesn't call other Solidity functions directly, but uses the assembly `revert` instruction."
    },
    {
      "type": "internal pure",
      "function_name": "revertWith(bytes4 selector, uint256 amount1, uint256 amount2)",
      "analysis_result": "This is an internal pure helper function to revert execution with a custom error selector and two uint256 arguments. It takes three parameters: `selector` (bytes4), `amount1` (uint256), and `amount2` (uint256). It uses Yul assembly to prepare the revert data. It stores the `selector` at memory offset 0 (`mstore(0, selector)`), `amount1` at memory offset 0x04 (`mstore(0x04, amount1)`), and `amount2` at memory offset 0x24 (`mstore(0x24, amount2)`). It then reverts using `revert(0, 0x44)`, indicating the data starts at offset 0 and has a length of 0x44 bytes (4 bytes for the selector + 32 bytes for amount1 + 32 bytes for amount2). No state variables are accessed or modified. It doesn't call other Solidity functions directly, but uses the assembly `revert` instruction."
    },
    {
      "type": "internal pure",
      "function_name": "revertWith(bytes4 selector, address addr1, address addr2)",
      "analysis_result": "This is an internal pure helper function to revert execution with a custom error selector and two address arguments. It takes three parameters: `selector` (bytes4), `addr1` (address), and `addr2` (address). It uses Yul assembly to prepare the revert data. It stores the `selector` at memory offset 0 (`mstore(0, selector)`), `addr1` at memory offset 0x04 (`mstore(0x04, addr1)`), and `addr2` at memory offset 0x24 (`mstore(0x24, addr2)`). It then reverts using `revert(0, 0x44)`, indicating the data starts at offset 0 and has a length of 0x44 bytes (4 bytes for the selector + 32 bytes for addr1 + 32 bytes for addr2). No state variables are accessed or modified. It doesn't call other Solidity functions directly, but uses the assembly `revert` instruction."
    }
  ],
  "Utils.revertFor": {
    "type": "internal pure",
    "function_name": "revertFor(bytes memory reason)",
    "analysis_result": "This is an internal pure helper function used to revert execution using the data provided in the `reason` bytes. This allows reverting with standard strings (Error(string)) or pre-encoded custom error data. It takes one parameter: `reason` (bytes memory), containing the encoded revert reason. The function uses Yul assembly. It calculates the memory address of the reason data payload by adding 0x20 (the standard offset for dynamic bytes data after the length) to the start of the `reason` variable's memory location (`add(reason, 0x20)`). It loads the length of the reason data from the first 32 bytes of the `reason` variable (`mload(reason)`). It then calls the `revert` assembly instruction using the calculated data address and loaded length (`revert(add(reason, 0x20), mload(reason))`). No state variables are accessed or modified. It doesn't call other Solidity functions directly, but uses the assembly `revert` instruction."
  },
  "Utils.safeIncreaseAllowance": {
    "type": "internal",
    "function_name": "safeIncreaseAllowance(address token, address spender, uint256 amount)",
    "analysis_result": "This internal function increases the ERC20 allowance of the calling contract (`address(this)`) on a specific `token` for a given `spender` by the specified `amount`. It takes three parameters: `token` (address of the ERC20 token), `spender` (address to grant allowance to), and `amount` (uint256) by which to increase the allowance. It uses an `unchecked` block for the addition to calculate the new allowance, relying on an explicit overflow check. It first calls the internal `allowance` function to retrieve the current allowance (`oldAllowance`) that `address(this)` has for `spender` on `token`. It calculates `newAllowance = oldAllowance + amount`. It then checks if `newAllowance < oldAllowance`; if true, this indicates an unsigned integer overflow has occurred, and it reverts by calling the internal `revertWith(IncreaseAllowanceOverflow.selector)`. If no overflow, it calls the external `safeApprove` function on the `token` contract (using SafeTransferLib) to set the allowance to `newAllowance`. This pattern prevents issues with ERC20 tokens that fail when `approve` is called with a non-zero current allowance. It uses the custom error `IncreaseAllowanceOverflow` and the constant `TRANSFER_GAS_LIMIT` is mentioned in the library but not directly used in this function. It calls the internal `allowance` function and the external `safeApprove` function via the `SafeTransferLib` helper. No state variables are accessed or modified by this library function, but the external token contract's state (allowance mapping) is modified."
  },
  "Utils.allowance": {
    "type": "internal view",
    "function_name": "allowance(address token, address owner, address spender)",
    "analysis_result": "This internal view function retrieves the ERC20 allowance granted by `owner` to `spender` for a specific `token`. It takes three parameters: `token` (address of the ERC20 token), `owner` (address granting the allowance), and `spender` (address receiving the allowance). It returns a `uint256` representing the allowance amount. The function uses Yul assembly to perform a low-level static call to the token contract. It prepares the call data for the standard ERC20 `allowance(address,address)` function selector (0xdd62ed3e) and arguments (`owner`, `spender`) in memory. It then performs a `staticcall` to the `token` address. `staticcall` is used because this is a view operation and should not change state. It checks if the return data size (`returndatasize()`) is at least 32 bytes (0x20), which is the expected size for a uint256 return value. It loads the first 32 bytes of the return data from memory (where the `staticcall` output is directed) using `mload(0)`. The final `amount` returned is the loaded value only if the `staticcall` was successful and returned at least 32 bytes; otherwise, it returns 0. This handles cases where the token contract might not exist, revert, or return unexpected data. No state variables are accessed or modified. It performs an external `staticcall` to the `token` address."
  },
  "Utils.trySafeTransfer": {
    "type": "internal",
    "function_name": "trySafeTransfer(address token, address to, uint256 amount)",
    "analysis_result": "This internal function attempts to transfer a specific `amount` of an ERC20 `token` from the current contract (`address(this)`) to the `to` address. It takes three parameters: `token` (address of the ERC20 token), `to` (address of the recipient), and `amount` (uint256) to transfer. It returns a `bool` indicating whether the transfer call was successful according to its checks. The function uses Yul assembly to perform a low-level call to the token contract's `transfer(address,uint256)` function. It prepares the call data for the standard ERC20 `transfer(address,uint256)` function selector (0xa9059cbb) and arguments (`to`, `amount`) in memory. It performs a `call` to the `token` address with a specific gas limit defined by the constant `TRANSFER_GAS_LIMIT`. This gas limit is used to prevent potential malicious token contracts from consuming excessive gas (griefing). After the call, it checks the result of the `call` instruction (which returns 1 on success, 0 on failure) and the return data. A transfer is considered successful if the call itself returns 1 AND the return data is either empty (`iszero(returndatasize())`) or the first 32 bytes of the return data are equal to 1 (`eq(mload(0x00), 1)`). This logic accounts for different ERC20 implementations (some return nothing on success, others return `true`). The boolean `success` is set based on this combined check. No state variables are accessed or modified by this library function, but the external token contract's state (balances mapping) is typically modified by the external `transfer` call. It uses the constant `TRANSFER_GAS_LIMIT` and performs an external `call` to the `token` address."
  },
  "Utils.changeDecimals": {
    "type": "internal pure",
    "function_name": "changeDecimals(uint256 amount, uint8 from, uint8 to)",
    "analysis_result": "This internal pure function converts a token `amount` from one decimal precision (`from`) to another (`to`). It takes three parameters: `amount` (uint256), `from` (uint8, the original number of decimals), and `to` (uint8, the target number of decimals). It returns the converted `uint256` amount. The function implements a simple conditional logic: if `from` equals `to`, it returns the original `amount`. If `from` is greater than `to` (decreasing precision), it divides the `amount` by `10` raised to the power of the difference in decimals (`from - to`). If `to` is greater than `from` (increasing precision), it multiplies the `amount` by `10` raised to the power of the difference in decimals (`to - from`). Note that the division for `from > to` might result in a loss of precision if the `amount` is not perfectly divisible. It doesn't use or call any other functions or access state variables. All calculations are done directly on the input parameters."
  },
  "RewardVault_V3.constructor": {
    "type": "public",
    "function_name": "constructor()",
    "analysis_result": "The constructor initializes the upgradeable contract state by calling `_disableInitializers()`. This function is part of the OpenZeppelin Upgrades library pattern and prevents the `initialize` function from being called outside of the proxy's `initialize` call. It does not read or modify any storage variables directly in this contract's state."
  },
  "RewardVault_V3.initialize": {
    "type": "external",
    "function_name": "initialize(address _beaconDepositContract, address _bgt, address _distributor, address _stakingToken)",
    "analysis_result": "This is the initializer function for the upgradeable contract, called once upon deployment via the proxy. It is protected by the `initializer` modifier. It performs the initial setup by calling the initializer functions of its base contracts: `__FactoryOwnable_init` (setting `msg.sender` as the factory owner), `__Pausable_init`, `__ReentrancyGuard_init`, and `__StakingRewards_init` (setting the staking token, reward token `_bgt`, and an initial rewards duration of 3 days). It sets the `maxIncentiveTokensCount` to 2, the `distributor` address, and the `beaconDepositContract` address. It emits the `DistributorSet` and `MaxIncentiveTokensCountUpdated` events."
  },
  "RewardVault_V3.onlyDistributor": {
    "type": "internal",
    "function_name": "onlyDistributor()",
    "analysis_result": "This is a modifier used for access control. It checks if `msg.sender` is equal to the stored `distributor` address. If the addresses do not match, it reverts the transaction with the `NotDistributor` error selector. It reads the `distributor` state variable and `msg.sender`. It does not modify any storage variables or call other functions."
  },
  "RewardVault_V3.onlyOperatorOrUser": {
    "type": "internal",
    "function_name": "onlyOperatorOrUser(address account)",
    "analysis_result": "This is a modifier for access control allowing either the specified `account` or their registered `operator` to call the function. It first checks if `msg.sender` is equal to the `account`. If not, it checks if `msg.sender` is equal to the operator stored for the `account` in the `_operators` mapping. If neither check passes, it reverts with the `NotOperator` error selector. It reads the `_operators` mapping and `msg.sender`."
  },
  "RewardVault_V3.checkSelfStakedBalance": {
    "type": "internal",
    "function_name": "checkSelfStakedBalance(address account, uint256 amount)",
    "analysis_result": "This is a modifier that ensures the `account` has a sufficient balance that they staked themselves (not delegated to them) before proceeding. It calls the internal helper function `_checkSelfStakedBalance(account, amount)`. It reads the `account` and `amount` parameters and indirectly reads storage variables via the helper function."
  },
  "RewardVault_V3.onlyWhitelistedToken": {
    "type": "internal",
    "function_name": "onlyWhitelistedToken(address token)",
    "analysis_result": "This is a modifier for access control that verifies if a given `token` address is currently whitelisted as an incentive token. It checks if the `minIncentiveRate` for the `token` stored in the `incentives` mapping is greater than 0. A zero `minIncentiveRate` indicates the token is not whitelisted. If the token is not whitelisted, it reverts with the `TokenNotWhitelisted` error selector. It reads the `incentives` mapping for the given `token`."
  },
  "RewardVault_V3.setDistributor": {
    "type": "external",
    "function_name": "setDistributor(address _rewardDistribution)",
    "analysis_result": "This function allows the `onlyFactoryOwner` to update the address of the `distributor` contract. It first checks if the provided `_rewardDistribution` address is the zero address, reverting if it is. It then updates the `distributor` state variable. Finally, it emits the `DistributorSet` event. It reads `_rewardDistribution` and modifies the `distributor` state variable."
  },
  "RewardVault_V3.notifyRewardAmount": {
    "type": "external",
    "function_name": "notifyRewardAmount(bytes calldata pubkey, uint256 reward)",
    "analysis_result": "This function is called by the `onlyDistributor` to signal that a new amount of BGT `reward` is available for distribution and to trigger the distribution of whitelisted incentives. It first calls the internal `_notifyRewardAmount(reward)` function (inherited from `StakingRewards`) to update the BGT rewards state variables. Then, it calls the internal `_processIncentives(pubkey, reward)` function to distribute the whitelisted incentive tokens based on the validator `pubkey` and the amount of BGT `reward` emitted. It reads `pubkey` and `reward`, and modifies internal StakingRewards state and incentive state via the called internal functions."
  },
  "RewardVault_V3.recoverERC20": {
    "type": "external",
    "function_name": "recoverERC20(address tokenAddress, uint256 tokenAmount)",
    "analysis_result": "This function allows the `onlyFactoryOwner` to recover ERC20 tokens that were accidentally sent to the contract. It prevents recovering the `stakeToken` or any currently whitelisted incentive token (by checking if `incentives[tokenAddress].minIncentiveRate` is non-zero). If the token is allowed to be recovered, it transfers the specified `tokenAmount` of `tokenAddress` to `msg.sender` using `safeTransfer`. It emits the `Recovered` event upon successful transfer. It reads `tokenAddress`, `tokenAmount`, `stakeToken`, `incentives`, and `msg.sender`. It modifies the balance of `tokenAddress` for the contract and `msg.sender` via an external call."
  },
  "RewardVault_V3.setRewardsDuration": {
    "type": "external",
    "function_name": "setRewardsDuration(uint256 _rewardsDuration)",
    "analysis_result": "This function allows the `onlyFactoryOwner` to update the duration over which BGT rewards are distributed. It calls the internal `_setRewardsDuration(_rewardsDuration)` function, inherited from `StakingRewards`, which handles the update logic and validation. It reads `_rewardsDuration` and modifies internal StakingRewards state variables."
  },
  "RewardVault_V3.whitelistIncentiveToken": {
    "type": "external",
    "function_name": "whitelistIncentiveToken(address token, uint256 minIncentiveRate, address manager)",
    "analysis_result": "This function allows the `onlyFactoryOwner` to add a new token to the list of supported incentive tokens. It validates the input parameters: `minIncentiveRate` must be non-zero and not exceed `MAX_INCENTIVE_RATE`, and `token` and `manager` addresses must not be zero. It checks if the `whitelistedTokens` list has reached its `maxIncentiveTokensCount` limit or if the `token` is already whitelisted (by checking `incentives[token].minIncentiveRate`). If valid and not already whitelisted, it adds the `token` to the `whitelistedTokens` array, sets the `incentives[token]` data (setting both `incentiveRate` and `minIncentiveRate` to the provided `minIncentiveRate`, `amountRemaining` to 0, and `manager`), and emits the `IncentiveTokenWhitelisted` event. It reads `token`, `minIncentiveRate`, `manager`, `MAX_INCENTIVE_RATE`, `whitelistedTokens.length`, `maxIncentiveTokensCount`, and `incentives`. It modifies `whitelistedTokens` and the `incentives` mapping."
  },
  "RewardVault_V3.removeIncentiveToken": {
    "type": "external",
    "function_name": "removeIncentiveToken(address token)",
    "analysis_result": "This function allows the `onlyFactoryVaultManager` to remove a whitelisted incentive token. It is protected by the `onlyWhitelistedToken(token)` modifier to ensure the token is actually whitelisted. It deletes the entry for the `token` from the `incentives` mapping and calls the internal helper `_deleteWhitelistedTokenFromList(token)` to remove the token from the `whitelistedTokens` array. It then emits the `IncentiveTokenRemoved` event. It reads `token` and modifies the `incentives` mapping and the `whitelistedTokens` array."
  },
  "RewardVault_V3.updateIncentiveManager": {
    "type": "external",
    "function_name": "updateIncentiveManager(address token, address newManager)",
    "analysis_result": "This function allows the `onlyFactoryOwner` to change the manager address for an existing whitelisted incentive token. It is protected by the `onlyWhitelistedToken(token)` modifier. It checks if the `newManager` address is zero, reverting if it is. It updates the `manager` field within the `incentives[token]` struct. It emits the `IncentiveManagerChanged` event, including the old and new manager addresses. It reads `token`, `newManager`, and `incentives`. It modifies the `manager` field within `incentives[token]`."
  },
  "RewardVault_V3.setMaxIncentiveTokensCount": {
    "type": "external",
    "function_name": "setMaxIncentiveTokensCount(uint8 _maxIncentiveTokensCount)",
    "analysis_result": "This function allows the `onlyFactoryOwner` to set the maximum number of incentive tokens that can be whitelisted at any time. It checks if the new `_maxIncentiveTokensCount` is less than the current number of whitelisted tokens (`whitelistedTokens.length`), reverting if it is to prevent making already whitelisted tokens unmanageable. It updates the `maxIncentiveTokensCount` state variable and emits the `MaxIncentiveTokensCountUpdated` event. It reads `_maxIncentiveTokensCount` and `whitelistedTokens.length`, and modifies `maxIncentiveTokensCount`."
  },
  "RewardVault_V3.pause": {
    "type": "external",
    "function_name": "pause()",
    "analysis_result": "This function allows the `onlyFactoryVaultPauser` to pause the contract, preventing execution of functions protected by `whenNotPaused`. It calls the internal `_pause()` function from the `PausableUpgradeable` base contract, which updates the pausable state and emits a `Paused` event. It modifies the pausable state."
  },
  "RewardVault_V3.unpause": {
    "type": "external",
    "function_name": "unpause()",
    "analysis_result": "This function allows the `onlyFactoryVaultManager` to unpause the contract, allowing execution of functions protected by `whenNotPaused`. It calls the internal `_unpause()` function from the `PausableUpgradeable` base contract, which updates the pausable state and emits an `Unpaused` event. It modifies the pausable state."
  },
  "RewardVault_V3.operator": {
    "type": "external view",
    "function_name": "operator(address account)",
    "analysis_result": "This is a view function that returns the address of the operator registered for a given `account`. It reads the `_operators` mapping for the specified `account`. It does not modify any storage variables or call other functions."
  },
  "RewardVault_V3.getWhitelistedTokensCount": {
    "type": "external view",
    "function_name": "getWhitelistedTokensCount()",
    "analysis_result": "This is a view function that returns the current number of whitelisted incentive tokens. It reads the length of the `whitelistedTokens` array. It does not modify any storage variables or call other functions."
  },
  "RewardVault_V3.getWhitelistedTokens": {
    "type": "public view",
    "function_name": "getWhitelistedTokens()",
    "analysis_result": "This is a view function that returns the array of addresses of all currently whitelisted incentive tokens. It reads the `whitelistedTokens` array. It does not modify any storage variables or call other functions."
  },
  "RewardVault_V3.getTotalDelegateStaked": {
    "type": "external view",
    "function_name": "getTotalDelegateStaked(address account)",
    "analysis_result": "This is a view function that returns the total amount of tokens that have been staked *on behalf of* the given `account` by delegates. It reads the `delegateTotalStaked` field from the `_delegateStake` struct associated with the `account`. It does not modify any storage variables or call other functions."
  },
  "RewardVault_V3.getDelegateStake": {
    "type": "external view",
    "function_name": "getDelegateStake(address account, address delegate)",
    "analysis_result": "This is a view function that returns the amount of tokens that a specific `delegate` has staked *on behalf of* a specific `account`. It reads the `stakedByDelegate` mapping within the `_delegateStake` struct associated with the `account`, using the `delegate` address as the key. It does not modify any storage variables or call other functions."
  },
  "RewardVault_V3.stake": {
    "type": "external",
    "function_name": "stake(uint256 amount)",
    "analysis_result": "This function allows `msg.sender` to stake a specified `amount` of the staking token. It is protected by the `nonReentrant` and `whenNotPaused` modifiers. It calls the internal `_stake(msg.sender, amount)` function, inherited from `StakingRewards`. This internal function handles the actual token transfer from the user to the contract, updates the user's stake balance (`_accountInfo[msg.sender].balance`), and updates the total supply of staked tokens (`totalSupply`). It reads `msg.sender` and `amount` and modifies staking state variables via the internal call."
  },
  "RewardVault_V3.delegateStake": {
    "type": "external",
    "function_name": "delegateStake(address account, uint256 amount)",
    "analysis_result": "This function allows `msg.sender` (a delegate) to stake a specified `amount` of the staking token *on behalf of* another `account`. It is protected by the `nonReentrant` and `whenNotPaused` modifiers. It checks that `msg.sender` is not the same as the `account`. It calls the internal `_stake(account, amount)` function (from `StakingRewards`) to transfer tokens from the delegate (`msg.sender` indirectly via approval/transferFrom) to the contract and update the `account`'s total stake balance. It then updates the `_delegateStake[account]` struct, incrementing `delegateTotalStaked` (the total staked for the account by any delegate) and `stakedByDelegate[msg.sender]` (the amount staked by this specific delegate for this account). It uses an unchecked block for the increments, assuming overflow is prevented by the checks within `_stake`. It emits the `DelegateStaked` event. It reads `msg.sender`, `account`, `amount` and modifies staking state variables via `_stake` and the `_delegateStake` mapping."
  },
  "RewardVault_V3.withdraw": {
    "type": "external",
    "function_name": "withdraw(uint256 amount)",
    "analysis_result": "This function allows `msg.sender` to withdraw a specified `amount` of their *self-staked* tokens. It is protected by the `nonReentrant` and `checkSelfStakedBalance(msg.sender, amount)` modifiers. The modifier ensures that the amount being withdrawn does not exceed the amount `msg.sender` staked themselves (total balance minus delegated stake). It calls the internal `_withdraw(msg.sender, amount)` function (inherited from `StakingRewards`), which handles the actual token transfer from the contract back to the user and updates the user's stake balance (`_accountInfo[msg.sender].balance`) and the total supply (`totalSupply`). It reads `msg.sender` and `amount` and modifies staking state variables via the internal call."
  },
  "RewardVault_V3.delegateWithdraw": {
    "type": "external",
    "function_name": "delegateWithdraw(address account, uint256 amount)",
    "analysis_result": "This function allows `msg.sender` (a delegate) to withdraw a specified `amount` of tokens they previously staked *on behalf of* another `account`. It is protected by the `nonReentrant` modifier. It checks that `msg.sender` is not the same as the `account`. It retrieves the amount staked by this delegate for this account (`stakedByDelegate`). It checks if this amount is sufficient for the withdrawal, reverting with `InsufficientDelegateStake` if not. It then updates the `_delegateStake[account]` struct, decrementing `stakedByDelegate[msg.sender]` and `delegateTotalStaked`. It uses an unchecked block for the decrements, as sufficiency is checked. Finally, it calls the internal `_withdraw(account, amount)` function (from `StakingRewards`) to reduce the `account`'s total stake balance and transfer tokens out of the contract. It emits the `DelegateWithdrawn` event. It reads `msg.sender`, `account`, `amount`, and the `_delegateStake` mapping. It modifies the `_delegateStake` mapping and staking state variables via `_withdraw`."
  },
  "RewardVault_V3.getReward": {
    "type": "external",
    "function_name": "getReward(address account, address recipient)",
    "analysis_result": "This function allows an `account` or their registered `operator` to claim earned BGT rewards, sending them to a specified `recipient`. It is protected by the `nonReentrant` and `onlyOperatorOrUser(account)` modifiers. It calls the internal `_getReward(account, recipient)` function (inherited from `StakingRewards`), which calculates the pending reward for the `account`, updates the account's reward tracking state, and transfers the reward token to the `recipient`. It returns the amount of reward claimed. It reads `account` and `recipient`, and modifies reward state variables via the internal call and triggers an external token transfer."
  },
  "RewardVault_V3.exit": {
    "type": "external",
    "function_name": "exit(address recipient)",
    "analysis_result": "This function allows `msg.sender` to withdraw all of their *self-staked* tokens and claim their earned BGT rewards, sending the rewards to a specified `recipient`. It is protected by the `nonReentrant` modifier. It calculates the `amount` of self-staked tokens by subtracting the total delegated stake for `msg.sender` (`_delegateStake[msg.sender].delegateTotalStaked`) from their total balance (`_accountInfo[msg.sender].balance`). It then calls `_withdraw(msg.sender, amount)` to withdraw the self-staked tokens and `_getReward(msg.sender, recipient)` to claim BGT rewards. It reads `msg.sender`, `recipient`, `_accountInfo`, and `_delegateStake`. It modifies staking and reward state variables via the internal calls and triggers external token transfers."
  },
  "RewardVault_V3.setOperator": {
    "type": "external",
    "function_name": "setOperator(address _operator)",
    "analysis_result": "This function allows `msg.sender` to set or update their designated operator address. The `_operator` address can then call functions restricted by the `onlyOperatorOrUser` modifier on behalf of `msg.sender`. It updates the `_operators` mapping for `msg.sender` with the provided `_operator` address. It emits the `OperatorSet` event. It reads `msg.sender` and `_operator`, and modifies the `_operators` mapping."
  },
  "RewardVault_V3.addIncentive": {
    "type": "external",
    "function_name": "addIncentive(address token, uint256 amount, uint256 incentiveRate)",
    "analysis_result": "This function allows the registered `manager` of a `token` to add more funds to the contract's incentive pool for that token and potentially update the `incentiveRate`. It is protected by the `nonReentrant` and `onlyWhitelistedToken(token)` modifiers. It validates the inputs: `incentiveRate` must not exceed `MAX_INCENTIVE_RATE`, `msg.sender` must be the token's manager, the `amount` must be at least the token's `minIncentiveRate`, and the new `incentiveRate` must be at least the `minIncentiveRate`. It transfers the specified `amount` of the `token` from `msg.sender` to the contract using `safeTransferFrom`. It increases `incentives[token].amountRemaining` by the added `amount`. It updates `incentives[token].incentiveRate`: it can be updated if the `amountRemainingBefore` was 0, or if the new rate is greater than or equal to the stored rate. It reverts if `amountRemainingBefore` was non-zero and the new rate is less than the stored rate. It emits the `IncentiveAdded` event. It reads `token`, `amount`, `incentiveRate`, `MAX_INCENTIVE_RATE`, `incentives`, and `msg.sender`. It modifies `incentives[token].amountRemaining` and `incentives[token].incentiveRate`, and the token balance via external call."
  },
  "RewardVault_V3.accountIncentives": {
    "type": "external",
    "function_name": "accountIncentives(address token, uint256 amount)",
    "analysis_result": "This function allows the registered `manager` of a `token` to account for a specified `amount` of that token that is already present in the contract's balance, adding it to the `amountRemaining` for distribution. It is protected by the `nonReentrant` and `onlyWhitelistedToken(token)` modifiers. It checks that `msg.sender` is the token's manager and validates that the `amount` is at least the token's `minIncentiveRate`. It verifies that the contract's current balance of the `token` is sufficient to cover the sum of the existing `amountRemaining` and the `amount` being accounted for. It increases `incentives[token].amountRemaining` by the `amount`. It emits the `IncentiveAdded` event (using the existing `incentiveRateStored`). It reads `token`, `amount`, `incentives`, `msg.sender`, and the contract's token balance via external call. It modifies `incentives[token].amountRemaining`."
  },
  "RewardVault_V3._checkSelfStakedBalance": {
    "type": "internal view",
    "function_name": "_checkSelfStakedBalance(address account, uint256 amount)",
    "analysis_result": "This internal helper function calculates the self-staked balance for an `account` (total balance minus total delegated stake) and checks if it is greater than or equal to the specified `amount`. If the self-staked balance is less than the `amount`, it reverts with the `InsufficientSelfStake` error selector. It uses an unchecked block for the subtraction, assuming `_accountInfo[account].balance` is always greater than or equal to `_delegateStake[account].delegateTotalStaked`. It reads `account`, `amount`, `_accountInfo`, and `_delegateStake`."
  },
  "RewardVault_V3._safeTransferRewardToken": {
    "type": "internal override",
    "function_name": "_safeTransferRewardToken(address to, uint256 amount)",
    "analysis_result": "This internal function overrides the base `StakingRewards` implementation to handle the transfer of BGT rewards. It transfers the specified `amount` of the `rewardToken` from the `distributor` address to the `to` address using `safeTransferFrom`. This requires the `distributor` to have previously approved this contract to spend its reward tokens. It reads `to`, `amount`, and `distributor`, and triggers an external transfer call on the `rewardToken`."
  },
  "RewardVault_V3._checkRewardSolvency": {
    "type": "internal view override",
    "function_name": "_checkRewardSolvency()",
    "analysis_result": "This internal view function overrides the base `StakingRewards` implementation to check if the distributor has provided sufficient allowance for the rewards that have been notified but not yet distributed. It checks if the `undistributedRewards` (divided by `PRECISION`, implying `undistributedRewards` is stored in a scaled format) is greater than the `rewardToken` allowance granted by the `distributor` to this contract. If it is, it reverts with the `InsolventReward` error selector. It reads `rewardToken`, `distributor`, `undistributedRewards`, and `PRECISION`, and makes an external view call to `allowance` on the `rewardToken` contract."
  },
  "RewardVault_V3._processIncentives": {
    "type": "internal",
    "function_name": "_processIncentives(bytes calldata pubkey, uint256 bgtEmitted)",
    "analysis_result": "This internal function is called by `notifyRewardAmount` to distribute whitelisted incentive tokens when BGT is emitted for a validator. It retrieves the validator's `_operator` address from the `beaconDepositContract` using the `pubkey`. It gets the addresses of the `beraChef` and `bgtIncentiveDistributor` from the `distributor` contract. It iterates through the `whitelistedTokens`. For each token, it calculates the proportional `amount` of incentive to distribute based on the `bgtEmitted` and the token's `incentiveRate` using `FixedPointMathLib.mulDiv`, capping the amount at the available `amountRemaining`. If `amount > 0`, it calculates the `validatorShare` using `beraChef.getValidatorIncentiveTokenShare`. It attempts to `trySafeTransfer` the `validatorShare` to the `_operator`, emitting `IncentivesProcessed` or `IncentivesProcessFailed`. If there's a remaining amount for BGT boosters, it attempts two low-level calls with `SAFE_GAS_LIMIT`: first `approve` the `bgtIncentiveDistributor` on the incentive token, then call `bgtIncentiveDistributor.receiveIncentive`. Successes are logged with `BGTBoosterIncentivesProcessed`, failures with `BGTBoosterIncentivesProcessFailed`. If the `receiveIncentive` call fails, it attempts to reset the allowance to zero to prevent issues with some token types. Finally, it updates `incentives[token].amountRemaining` based on successful transfers. It reads `pubkey`, `bgtEmitted`, `beaconDepositContract`, `distributor`, `whitelistedTokens`, `incentives`, `PRECISION`, `SAFE_GAS_LIMIT` and modifies `incentives[token].amountRemaining`. It makes several external calls to other contracts (`beaconDepositContract`, `distributor`, `beraChef`, `bgtIncentiveDistributor`, incentive tokens)."
  },
  "RewardVault_V3._deleteWhitelistedTokenFromList": {
    "type": "internal",
    "function_name": "_deleteWhitelistedTokenFromList(address token)",
    "analysis_result": "This internal helper function removes a specific `token` address from the `whitelistedTokens` array. It iterates through the array. When it finds the `token`, it replaces the element at the current index `i` with the last element in the array and then reduces the array size by one using `pop()`. It uses an unchecked block for loop indexing and array access, assuming the list is not empty (checked by the `onlyWhitelistedToken` modifier). It modifies the `whitelistedTokens` array."
  },
  "IHoneyFactory.mint": {
    "type": "external",
    "function_name": "mint(address asset, uint256 amount, address receiver, bool expectBasketMode) returns (uint256)",
    "analysis_result": "This is an external function declared in the IHoneyFactory interface. It is intended to allow users to mint Honey tokens by providing a specified amount of a collateral asset. The function takes the address of the collateral 'asset', the 'amount' of the asset to provide, the address of the 'receiver' who will receive the minted Honey, and an 'expectBasketMode' boolean flag. The flag is used by the client to communicate their expectation of the factory's basket mode status, potentially allowing the transaction to revert if the mode changes unexpectedly between signing and execution. The function is expected to return the 'uint256' amount of Honey that was minted. In a concrete implementation, this function would handle transferring the 'amount' of 'asset' from the caller (or an approved address) to the factory contract, calculate the corresponding amount of Honey based on internal logic (likely involving price oracles, mint rates, and the current mode), mint the calculated amount of Honey, and transfer it to the 'receiver'. It would likely emit the 'HoneyMinted' event. The actual storage variables read/modified would depend on the concrete contract implementation, but would likely include collateral balances, total supply of Honey, and potentially basket/mode-related state."
  },
  "IHoneyFactory.redeem": {
    "type": "external",
    "function_name": "redeem(address asset, uint256 honeyAmount, address receiver, bool expectBasketMode) returns (uint256[] memory)",
    "analysis_result": "This is an external function declared in the IHoneyFactory interface. It is intended to allow users to redeem collateral assets by burning Honey tokens. The function takes the address of the desired collateral 'asset', the 'honeyAmount' to burn, the address of the 'receiver' who will receive the redeemed assets, and an 'expectBasketMode' boolean flag similar to the 'mint' function. The function is expected to return a 'uint256[] memory' array containing the amount(s) of asset(s) that were redeemed. The array return type suggests that under certain conditions (likely in basket mode), multiple assets could be redeemed, or the structure is kept general. In a concrete implementation, this function would handle transferring 'honeyAmount' of Honey from the caller (or an approved address) to the factory contract for burning, calculate the corresponding amount(s) of 'asset' (or assets) based on internal logic (likely involving price oracles, redemption rates, and the current mode), transfer the calculated amount(s) of assets to the 'receiver', and burn the Honey. It would likely emit the 'HoneyRedeemed' event. Implementation details regarding storage access would depend on the concrete contract."
  },
  "IHoneyFactory.liquidate": {
    "type": "external",
    "function_name": "liquidate(address badCollateral, address goodCollateral, uint256 goodAmount) returns (uint256 badAmount)",
    "analysis_result": "This is an external function declared in the IHoneyFactory interface. It provides a mechanism for liquidation within the protocol, allowing users to help recapitalize undercollateralized positions. It takes the address of the 'badCollateral' asset that is deficient, the address of the 'goodCollateral' asset that the liquidator will provide, and the 'goodAmount' of 'goodCollateral' being provided. The function is expected to return a 'uint256 badAmount', representing the amount of 'badCollateral' received by the liquidator in exchange for the 'goodAmount' of 'goodCollateral'. In a concrete implementation, this function would handle transferring the 'goodAmount' of 'goodCollateral' from the caller to the factory, calculating the amount of 'badCollateral' the caller receives based on liquidation rates and prices, transferring that 'badAmount' of 'badCollateral' to the caller, and updating internal balances. It likely checks if liquidation is currently enabled (related to the 'LiquidationStatusSet' event) and would emit the 'Liquidated' event. Storage modifications would involve the balances of both collateral types within the factory."
  },
  "IHoneyFactory.recapitalize": {
    "type": "external",
    "function_name": "recapitalize(address asset, uint256 amount)",
    "analysis_result": "This is an external function declared in the IHoneyFactory interface. Its purpose is to allow users to contribute additional amounts of a specific collateral 'asset' to the factory's reserves, likely to help restore its health or exceed a certain balance threshold. It takes the address of the 'asset' to recapitalize and the 'amount' of that asset to provide. The function does not return any value. In a concrete implementation, this function would handle transferring the specified 'amount' of the 'asset' from the caller to the factory contract and updating the internal balance tracking for that specific collateral asset. It might have checks based on thresholds ('RecapitalizeBalanceThresholdSet' event) or minimum amounts ('MinSharesToRecapitalizeSet' event). It would likely emit the 'Recapitalized' event. Storage modifications would involve the balance of the specified 'asset' held by the factory."
  },
  "HoneyFactoryReader.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "The constructor disables the initializers for the contract. This is standard practice for upgradeable contracts using the UUPS pattern to prevent double initialization."
  },
  "HoneyFactoryReader.initialize": {
    "type": "external",
    "function_name": "initialize(address admin, address honeyFactory_)",
    "analysis_result": "This function is the initializer for the upgradeable contract. It is marked `external` and uses the `initializer` modifier, ensuring it can only be called once. It initializes the `AccessControlUpgradeable` and `UUPSUpgradeable` components. It checks if the provided `honeyFactory_` address is zero, reverting if it is (`ZeroAddress.selector.revertWith()`). It sets the `honeyFactory` state variable to the provided address and grants the `DEFAULT_ADMIN_ROLE` to the specified `admin` address. It uses the `honeyFactory` state variable (write operation) and inherits logic from `__AccessControl_init()` and `__UUPSUpgradeable_init()`. It uses the `admin` and `honeyFactory_` parameters."
  },
  "HoneyFactoryReader._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This is an internal function overriding the UUPS base contract's authorization check for upgrades. It is marked `internal` and uses the `onlyRole(DEFAULT_ADMIN_ROLE)` modifier, restricting the ability to authorize an upgrade to only addresses holding the default admin role. This function doesn't modify any state variables directly but relies on the `AccessControlUpgradeable` state to enforce the role check."
  },
  "HoneyFactoryReader.previewMintCollaterals": {
    "type": "public",
    "function_name": "previewMintCollaterals(address asset, uint256 honey)",
    "analysis_result": "This `public view` function calculates the required amounts of collaterals to mint a specific amount of Honey. It reads from the `honeyFactory` state variable. It first retrieves the list of registered collaterals and their count by calling `_getCollaterals()`. It gets the weights of collaterals and checks if basket mode is enabled by calling `honeyFactory.getWeights()` and `honeyFactory.isBasketModeEnabled(true)`. It iterates through the registered collaterals. If not in basket mode, it only calculates the amount for the specific `asset` provided. If in basket mode or if the current asset is the target `asset` (and not in basket mode), it fetches the vault address (`honeyFactory.vaults(collaterals[i])`) and the mint rate (`honeyFactory.mintRates(collaterals[i])`) for the collateral. It calculates the required shares based on the desired `honey` amount, the asset's weight (or 1e18 if not in basket mode and it's the target asset), and the mint rate. Finally, it converts the required shares to the corresponding asset amount by calling `vault.convertToAssets(shares)` and stores it in the `amounts` array. The `asset` and `honey` parameters are read. It calls `_getCollaterals()`, `honeyFactory.getWeights()`, `honeyFactory.isBasketModeEnabled()`, `honeyFactory.vaults()`, `honeyFactory.mintRates()`, and `vault.convertToAssets()`. It reads `honeyFactory` state variable implicitly through the calls to its public/external view functions."
  },
  "HoneyFactoryReader.previewMintHoney": {
    "type": "external",
    "function_name": "previewMintHoney(address asset, uint256 amount)",
    "analysis_result": "This `external view` function calculates the expected amount of Honey obtainable and the amounts of all required collaterals when providing a specific `amount` of a single `asset`. It reads from the `honeyFactory` state variable. It first checks if basket mode is enabled by calling `honeyFactory.isBasketModeEnabled(true)`. It then calls `_getWeightedCollaterals(asset, amount, basketMode)` to determine the weighted amounts for all collaterals based on the input `asset` and `amount`. It retrieves the list of all registered assets and their count using `_getCollaterals()`. It then iterates through all collaterals, and for each, it calls `_previewMint(assets[i], collaterals[i])` to calculate the Honey obtainable from the computed amount of that specific collateral. The total `honey` is accumulated sum of Honey from all collaterals. It uses the `asset` and `amount` parameters. It calls `honeyFactory.isBasketModeEnabled()`, `_getWeightedCollaterals()`, `_getCollaterals()`, and `_previewMint()`. It reads `honeyFactory` state variable implicitly."
  },
  "HoneyFactoryReader.previewRedeemCollaterals": {
    "type": "external",
    "function_name": "previewRedeemCollaterals(address asset, uint256 honey)",
    "analysis_result": "This `external view` function calculates the amounts of collaterals obtainable when redeeming a specific amount of `honey`. It reads from the `honeyFactory` state variable. It retrieves the list of all registered assets and their count using `_getCollaterals()`. It checks if basket mode is enabled by calling `honeyFactory.isBasketModeEnabled(false)`. If not in basket mode, it finds the index of the target `asset` using `_getIndexOfAsset()` and calculates the obtainable amount for only that asset by calling `_previewRedeem(asset, honey)`. If in basket mode, it retrieves the collateral weights using `honeyFactory.getWeights()` and iterates through all registered assets, calculating the obtainable amount for each by calling `_previewRedeem(assets[i], honey * weights[i] / 1e18)`. It uses the `asset` and `honey` parameters. It calls `_getCollaterals()`, `honeyFactory.isBasketModeEnabled()`, `_getIndexOfAsset()`, `_previewRedeem()`, and `honeyFactory.getWeights()`. It reads `honeyFactory` state variable implicitly."
  },
  "HoneyFactoryReader.previewRedeemHoney": {
    "type": "external",
    "function_name": "previewRedeemHoney(address asset, uint256 amount)",
    "analysis_result": "This `external view` function calculates the amount of Honey required and the amounts of all collaterals obtainable when targeting a specific `amount` of a single `asset` for redemption. It reads from the `honeyFactory` state variable. It checks if basket mode is enabled by calling `honeyFactory.isBasketModeEnabled(false)`. It calls `_getWeightedCollaterals(asset, amount, basketMode)` to determine the weighted amounts for all collaterals based on the target `asset` and desired `amount`. It retrieves the list of all registered assets and their count using `_getCollaterals()`. It then iterates through all collaterals, and for each, it calls `_previewHoneyToRedeem(assets[i], collaterals[i])` to calculate the Honey required to redeem the computed amount of that specific collateral. The total `honey` required is the accumulated sum from all collaterals. It uses the `asset` and `amount` parameters. It calls `honeyFactory.isBasketModeEnabled()`, `_getWeightedCollaterals()`, `_getCollaterals()`, and `_previewHoneyToRedeem()`. It reads `honeyFactory` state variable implicitly."
  },
  "HoneyFactoryReader._previewMint": {
    "type": "internal",
    "function_name": "_previewMint(address asset, uint256 amount)",
    "analysis_result": "This `internal view` function calculates the amount of Honey obtainable from a given `amount` of a specific `asset`. It reads from the `honeyFactory` state variable. It fetches the ERC4626 vault address for the `asset` by calling `honeyFactory.vaults(asset)`. It then calculates the corresponding amount of vault shares using the vault's `previewDeposit(amount)` function. Finally, it converts these shares into the equivalent Honey amount by calling `_getHoneyMintedFromShares(asset, shares)`. It uses the `asset` and `amount` parameters. It calls `honeyFactory.vaults()`, `vault.previewDeposit()`, and `_getHoneyMintedFromShares()`. It reads `honeyFactory` state variable implicitly."
  },
  "HoneyFactoryReader._previewRedeem": {
    "type": "internal",
    "function_name": "_previewRedeem(address asset, uint256 honeyAmount)",
    "analysis_result": "This `internal view` function calculates the amount of a specific `asset` obtainable from a given `honeyAmount`. It reads from the `honeyFactory` state variable. It fetches the ERC4626 vault address for the `asset` by calling `honeyFactory.vaults(asset)`. It calculates the corresponding amount of vault shares using `_getSharesRedeemedFromHoney(asset, honeyAmount)`. Finally, it converts these shares back into the asset amount using the vault's `previewRedeem(shares)` function. It uses the `asset` and `honeyAmount` parameters. It calls `honeyFactory.vaults()`, `_getSharesRedeemedFromHoney()`, and `vault.previewRedeem()`. It reads `honeyFactory` state variable implicitly."
  },
  "HoneyFactoryReader._getCollaterals": {
    "type": "internal",
    "function_name": "_getCollaterals()",
    "analysis_result": "This `internal view` function retrieves the list of registered collateral asset addresses from the `honeyFactory`. It reads from the `honeyFactory` state variable. It gets the number of registered assets by calling `honeyFactory.numRegisteredAssets()` and creates a dynamic array of that size. It then iterates from 0 up to the number of assets, fetching each registered asset address by calling `honeyFactory.registeredAssets(i)` and storing it in the array. It returns the array of collateral addresses and the count. It calls `honeyFactory.numRegisteredAssets()` and `honeyFactory.registeredAssets()`. It reads `honeyFactory` state variable implicitly."
  },
  "HoneyFactoryReader._getHoneyMintedFromShares": {
    "type": "internal",
    "function_name": "_getHoneyMintedFromShares(address asset, uint256 shares)",
    "analysis_result": "This `internal view` function calculates the amount of Honey obtainable from a given amount of vault `shares` for a specific `asset`. It reads from the `honeyFactory` state variable. It fetches the mint rate for the `asset` by calling `honeyFactory.mintRates(asset)`. It then calculates the Honey amount by multiplying the shares by the mint rate and dividing by 1e18 (to account for 18 decimal precision in rates). It uses the `asset` and `shares` parameters. It calls `honeyFactory.mintRates()`. It reads `honeyFactory` state variable implicitly."
  },
  "HoneyFactoryReader._getSharesRedeemedFromHoney": {
    "type": "internal",
    "function_name": "_getSharesRedeemedFromHoney(address asset, uint256 honeyAmount)",
    "analysis_result": "This `internal view` function calculates the amount of vault `shares` obtainable from a given `honeyAmount` for a specific `asset`. It reads from the `honeyFactory` state variable. It fetches the redeem rate for the `asset` by calling `honeyFactory.redeemRates(asset)`. It then calculates the shares by multiplying the `honeyAmount` by the redeem rate and dividing by 1e18. It uses the `asset` and `honeyAmount` parameters. It calls `honeyFactory.redeemRates()`. It reads `honeyFactory` state variable implicitly."
  },
  "HoneyFactoryReader._getIndexOfAsset": {
    "type": "internal",
    "function_name": "_getIndexOfAsset(address[] memory collaterals, uint256 num, address asset)",
    "analysis_result": "This `internal pure` function finds the index of a specific `asset` within the `collaterals` array. It iterates through the array up to the specified `num` of elements. If the `asset` is found, it sets the `found` flag to `true`, stores the index `i`, and breaks the loop. It returns the found `index` and the `found` boolean flag. It uses the `collaterals`, `num`, and `asset` parameters. It does not interact with state variables or external contracts."
  },
  "HoneyFactoryReader._getWeightedCollaterals": {
    "type": "internal",
    "function_name": "_getWeightedCollaterals(address asset, uint256 amount, bool basketMode)",
    "analysis_result": "This `internal view` function calculates the amounts of all collaterals corresponding to a given `amount` of a single input `asset`, considering `basketMode`. It reads from the `honeyFactory` state variable. It retrieves the list of collaterals and their count using `_getCollaterals()`. It finds the index of the input `asset` using `_getIndexOfAsset()`. If `basketMode` is false, it simply returns an array with the input `amount` for the target `asset` and 0 for others. If `basketMode` is true, it retrieves the collateral weights using `honeyFactory.getWeights()`. It adjusts the input `amount` to 18 decimals using `Utils.changeDecimals()` and scales it by the weight of the input asset to get a reference amount (`refAmount`). It then iterates through all collaterals, calculates the weighted amount for each using `refAmount` and their respective weight, and converts this weighted amount (in 18 decimals) to the asset's native decimal representation using the corresponding vault's `convertToAssets()` function (`honeyFactory.vaults(collaterals[i]).convertToAssets(...)`). It stores these calculated amounts in the `res` array and returns it. It uses the `asset`, `amount`, and `basketMode` parameters. It calls `_getCollaterals()`, `_getIndexOfAsset()`, `honeyFactory.getWeights()`, `Utils.changeDecimals()`, `honeyFactory.vaults()`, and `vault.convertToAssets()`. It reads `honeyFactory` state variable implicitly."
  },
  "HoneyFactoryReader._previewHoneyToRedeem": {
    "type": "internal",
    "function_name": "_previewHoneyToRedeem(address asset, uint256 exactAmount)",
    "analysis_result": "This `internal view` function calculates the amount of Honey required to redeem an `exactAmount` of a specific `asset`. It reads from the `honeyFactory` state variable. It fetches the ERC4626 vault address for the `asset` by calling `honeyFactory.vaults(asset)`. It then calculates the corresponding amount of vault shares using the vault's `previewWithdraw(exactAmount)` function. It retrieves the redeem rate for the `asset` by calling `honeyFactory.redeemRates(asset)`. Finally, it calculates the required Honey amount by multiplying the shares by 1e18 and dividing by the redeem rate. It uses the `asset` and `exactAmount` parameters. It calls `honeyFactory.vaults()`, `vault.previewWithdraw()`, and `honeyFactory.redeemRates()`. It reads `honeyFactory` state variable implicitly."
  },
  "Honey.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor for the upgradeable contract. It follows the UUPS pattern by calling `_disableInitializers()`. This prevents direct calls to the `initialize` function immediately after deployment, ensuring initialization is handled via the proxy contract. It does not interact with storage variables defined in this contract but sets up the upgradeability mechanism."
  },
  "Honey.initialize": {
    "type": "external initializer",
    "function_name": "initialize(address _governance, address _factory)",
    "analysis_result": "This function serves as the initializer for the contract, called after deployment through the proxy. It is protected by the `initializer` modifier, ensuring it can only be called once. It initializes base contracts by calling `__AccessControl_init()` and `__UUPSUpgradeable_init()`. It performs validation checks to ensure the provided `_factory` and `_governance` addresses are not the zero address, reverting with a specific error selector (`ZeroAddress.selector`) if they are. If the addresses are valid, it sets the `factory` storage variable to the provided `_factory` address. It also grants the `DEFAULT_ADMIN_ROLE` (managed by the inherited `AccessControlUpgradeable` contract) to the `_governance` address using `_grantRole`. This function is critical for setting up the authorized factory address for minting/burning and the administrative role for upgrades."
  },
  "Honey._authorizeUpgrade": {
    "type": "internal override",
    "function_name": "_authorizeUpgrade(address)",
    "analysis_result": "This is an internal function overridden from `UUPSUpgradeable`. Its purpose is to define who is allowed to perform contract upgrades. It is protected by the `onlyRole(DEFAULT_ADMIN_ROLE)` modifier, which enforces that only addresses holding the `DEFAULT_ADMIN_ROLE` can successfully call this function and thus authorize an upgrade. It does not modify or read storage variables within the `Honey` contract itself, but the modifier checks the role information managed by `AccessControlUpgradeable`."
  },
  "Honey.onlyFactory": {
    "type": "modifier",
    "function_name": "onlyFactory()",
    "analysis_result": "This is a modifier used to restrict function calls to only the address stored in the `factory` storage variable. It checks if the caller's address (`msg.sender`) is equal to the `factory` address. If `msg.sender` is not the factory, the execution is reverted with the error selector `NotFactory.selector`. This modifier is applied to sensitive functions like `mint` and `burn` to ensure that only the designated factory contract can manage the token supply."
  },
  "Honey.mint": {
    "type": "external onlyFactory",
    "function_name": "mint(address to, uint256 amount)",
    "analysis_result": "This function allows for the creation (minting) of new Honey tokens. It is restricted by the `onlyFactory` modifier, meaning only the address stored in the `factory` variable can call it. It takes a recipient address `to` and a token `amount` as parameters. It internally calls the inherited `_mint(to, amount)` function from the `ERC20` base contract. The `_mint` function handles updating the recipient's balance and the total supply, and emits a `Transfer` event. This function is a key mechanism for the factory to introduce new Honey into circulation."
  },
  "Honey.burn": {
    "type": "external onlyFactory",
    "function_name": "burn(address from, uint256 amount)",
    "analysis_result": "This function allows for the destruction (burning) of existing Honey tokens. It is restricted by the `onlyFactory` modifier, meaning only the address stored in the `factory` variable can call it. It takes the account `from` from which tokens should be burned and the token `amount` as parameters. It internally calls the inherited `_burn(from, amount)` function from the `ERC20` base contract. The `_burn` function handles decreasing the account's balance and the total supply, and emits a `Transfer` event. This function is a key mechanism for the factory to remove Honey from circulation."
  },
  "Honey.name": {
    "type": "public pure override",
    "function_name": "name() public pure override returns (string memory)",
    "analysis_result": "This is a standard ERC20 function that returns the name of the token. It is marked as `pure` because it does not read or write to storage variables. It simply returns the constant string `NAME`, which is 'Honey'."
  },
  "Honey.symbol": {
    "type": "public pure override",
    "function_name": "symbol() public pure override returns (string memory)",
    "analysis_result": "This is a standard ERC20 function that returns the symbol of the token. It is marked as `pure` because it does not read or write to storage variables. It simply returns the constant string `SYMBOL`, which is 'HONEY'."
  },
  "HoneyFactory.constructor": {
    "type": "public",
    "function_name": "constructor()",
    "analysis_result": "Initializes the contract state by disabling initializers, a pattern used for upgradeable contracts. It does not interact with state variables directly but prepares the contract for the `initialize` function call. It uses the `_disableInitializers` function."
  },
  "HoneyFactory.initialize": {
    "type": "external",
    "function_name": "initialize(address _governance, address _honey, address _polFeeCollector, address _feeReceiver, address _priceOracle, address _beacon)",
    "analysis_result": "Serves as the post-deployment setup function for the upgradeable contract. It requires the `initializer` modifier. It takes addresses for governance, Honey token, POL fee collector, fee receiver, price oracle, and a beacon for vault creation. It checks that _honey and _priceOracle are not zero addresses, reverting if they are. It calls the `__VaultAdmin_init` function (inherited from VaultAdmin) to set up core roles (DEFAULT_ADMIN_ROLE, MANAGER_ROLE), the POL fee collector, the fee receiver, and the beacon address for cloning vaults. It sets the `honey` contract address, the `priceOracle` contract address, initializes `polFeeCollectorFeeRate` to 100% (`ONE_HUNDRED_PERCENT_RATE`), `priceFeedMaxDelay` to 10 seconds, `minSharesToRecapitalize` to `DEFAULT_MIN_SHARES_TO_RECAPITALIZE`, `globalCap` to 100% (`ONE_HUNDRED_PERCENT_RATE`), and `liquidationEnabled` to false. It emits `POLFeeCollectorFeeRateSet`, `MaxFeedDelaySet`, `MinSharesToRecapitalizeSet`, and `GlobalCapSet` events. Modifies `honey`, `polFeeCollectorFeeRate`, `priceFeedMaxDelay`, `minSharesToRecapitalize`, `priceOracle`, `globalCap`, `liquidationEnabled`, and state variables initialized by `__VaultAdmin_init` (like roles, fee collector/receiver addresses, beacon, etc.). Reverts if `_honey` or `_priceOracle` is address(0)."
  },
  "HoneyFactory.setMintRate": {
    "type": "external",
    "function_name": "setMintRate(address asset, uint256 mintRate)",
    "analysis_result": "Allows the `MANAGER_ROLE` to set the `mintRate` for a specific `asset`. It enforces access control using `_checkRole(MANAGER_ROLE)`. It validates that the `mintRate` is between 98% (`NINETY_EIGHT_PERCENT_RATE`) and 100% (`ONE_HUNDRED_PERCENT_RATE`), inclusive, reverting with `OverOneHundredPercentRate` or `UnderNinetyEightPercentRate` if outside this range. It updates the `mintRates` mapping for the given `asset`. Emits the `MintRateSet` event. Modifies `mintRates`. Reads `MANAGER_ROLE`, `ONE_HUNDRED_PERCENT_RATE`, `NINETY_EIGHT_PERCENT_RATE`. Calls `_checkRole`."
  },
  "HoneyFactory.setRedeemRate": {
    "type": "external",
    "function_name": "setRedeemRate(address asset, uint256 redeemRate)",
    "analysis_result": "Allows the `MANAGER_ROLE` to set the `redeemRate` for a specific `asset`. It enforces access control using `_checkRole(MANAGER_ROLE)`. It validates that the `redeemRate` is between 98% (`NINETY_EIGHT_PERCENT_RATE`) and 100% (`ONE_HUNDRED_PERCENT_RATE`), inclusive, reverting with `OverOneHundredPercentRate` or `UnderNinetyEightPercentRate` if outside this range. It updates the `redeemRates` mapping for the given `asset`. Emits the `RedeemRateSet` event. Modifies `redeemRates`. Reads `MANAGER_ROLE`, `ONE_HUNDRED_PERCENT_RATE`, `NINETY_EIGHT_PERCENT_RATE`. Calls `_checkRole`."
  },
  "HoneyFactory.setForcedBasketMode": {
    "type": "external",
    "function_name": "setForcedBasketMode(bool forced)",
    "analysis_result": "Allows the `MANAGER_ROLE` to explicitly enable or disable the basket mode, overriding the price oracle's influence. It enforces access control using `_checkRole(MANAGER_ROLE)`. It sets the `forcedBasketMode` state variable to the provided `forced` value. Emits the `BasketModeForced` event. Modifies `forcedBasketMode`. Reads `MANAGER_ROLE`. Calls `_checkRole`."
  },
  "HoneyFactory.setMaxFeedDelay": {
    "type": "external",
    "function_name": "setMaxFeedDelay(uint256 maxTolerance)",
    "analysis_result": "Allows the `MANAGER_ROLE` to set the maximum tolerated staleness for price oracle data in seconds. It enforces access control using `_checkRole(MANAGER_ROLE)`. It validates that `maxTolerance` is not greater than `MAX_PRICE_FEED_DELAY_TOLERANCE` (120 seconds), reverting with `AmountOutOfRange` if exceeded. It updates the `priceFeedMaxDelay` state variable. Emits the `MaxFeedDelaySet` event. Modifies `priceFeedMaxDelay`. Reads `MANAGER_ROLE`, `MAX_PRICE_FEED_DELAY_TOLERANCE`. Calls `_checkRole`."
  },
  "HoneyFactory.setDepegOffsets": {
    "type": "external",
    "function_name": "setDepegOffsets(address asset, uint256 lowerOffset, uint256 upperOffset)",
    "analysis_result": "Allows the `MANAGER_ROLE` to set the lower and upper deviation offsets from 1e18 for considering an asset pegged (USD = 1e18 price). It enforces access control using `_checkRole(MANAGER_ROLE)`. It checks if the `asset` is registered using `_checkRegisteredAsset`, reverting if not. It validates that both `lowerOffset` and `upperOffset` are not greater than `MAX_PEG_OFFSET` (0.02e18), reverting with `AmountOutOfRange` if exceeded. It updates the `lowerPegOffsets` and `upperPegOffsets` mappings for the given `asset`. Emits the `DepegOffsetsSet` event. Modifies `lowerPegOffsets`, `upperPegOffsets`. Reads `MANAGER_ROLE`, `MAX_PEG_OFFSET`. Calls `_checkRole`, `_checkRegisteredAsset`."
  },
  "HoneyFactory.setReferenceCollateral": {
    "type": "external",
    "function_name": "setReferenceCollateral(address asset)",
    "analysis_result": "Allows the `MANAGER_ROLE` to set the `asset` that is used as the reference for calculating relative cap limits. It enforces access control using `_checkRole(MANAGER_ROLE)`. It checks if the `asset` is registered using `_checkRegisteredAsset`, reverting if not. It stores the current `referenceCollateral` before updating the state variable. Emits the `ReferenceCollateralSet` event with the old and new reference collateral addresses. Modifies `referenceCollateral`. Reads `MANAGER_ROLE`, `referenceCollateral`. Calls `_checkRole`, `_checkRegisteredAsset`."
  },
  "HoneyFactory.setGlobalCap": {
    "type": "external",
    "function_name": "setGlobalCap(uint256 limit)",
    "analysis_result": "Allows the `MANAGER_ROLE` to set the maximum allowed weight for any single asset relative to the total weight of good collaterals. It enforces access control using `_checkRole(MANAGER_ROLE)`. It calculates the current weights of all registered assets (excluding bad collaterals and paused vaults) using `_getWeights(true, false)` and finds the maximum current weight. It validates that the new `limit` is not less than this maximum current weight, reverting with `CapCanCauseDenialOfService` if it is, to prevent immediate DoS on redemption. It updates the `globalCap` state variable. Emits the `GlobalCapSet` event. Modifies `globalCap`. Reads `MANAGER_ROLE`, `registeredAssets`, `isBadCollateralAsset`, `vaults`. Calls `_checkRole`, `_getWeights`, `_getSharesWithoutFees`, `vaults[].paused`."
  },
  "HoneyFactory.setRelativeCap": {
    "type": "external",
    "function_name": "setRelativeCap(address asset, uint256 limit)",
    "analysis_result": "Allows the `MANAGER_ROLE` to set the maximum allowed weight for a specific `asset` relative to the `referenceCollateral`. It enforces access control using `_checkRole(MANAGER_ROLE)`. It updates the `relativeCap` mapping for the given `asset`. Emits the `RelativeCapSet` event. Modifies `relativeCap`. Reads `MANAGER_ROLE`. Calls `_checkRole`. Note: Does not check if the asset is registered."
  },
  "HoneyFactory.setPOLFeeCollectorFeeRate": {
    "type": "external",
    "function_name": "setPOLFeeCollectorFeeRate(uint256 _polFeeCollectorFeeRate)",
    "analysis_result": "Allows the `DEFAULT_ADMIN_ROLE` to set the percentage of collected fees that are directed to the POL Fee Collector. The remaining percentage goes to the fee receiver. It enforces access control using `_checkRole(DEFAULT_ADMIN_ROLE)`. It validates that `_polFeeCollectorFeeRate` is not greater than `ONE_HUNDRED_PERCENT_RATE` (100%), reverting with `OverOneHundredPercentRate` if exceeded. It updates the `polFeeCollectorFeeRate` state variable. Emits the `POLFeeCollectorFeeRateSet` event. Modifies `polFeeCollectorFeeRate`. Reads `DEFAULT_ADMIN_ROLE`, `ONE_HUNDRED_PERCENT_RATE`. Calls `_checkRole`."
  },
  "HoneyFactory.setLiquidationEnabled": {
    "type": "external",
    "function_name": "setLiquidationEnabled(bool enabled)",
    "analysis_result": "Allows the `DEFAULT_ADMIN_ROLE` to enable or disable the liquidation mechanism. It enforces access control using `_checkRole(DEFAULT_ADMIN_ROLE)`. It sets the `liquidationEnabled` state variable to the provided `enabled` value. Emits the `LiquidationStatusSet` event. Modifies `liquidationEnabled`. Reads `DEFAULT_ADMIN_ROLE`. Calls `_checkRole`."
  },
  "HoneyFactory.setLiquidationRate": {
    "type": "external",
    "function_name": "setLiquidationRate(address asset, uint256 extraRate)",
    "analysis_result": "Allows the `DEFAULT_ADMIN_ROLE` to set the additional premium rate applied to the 'bad' collateral seized during liquidation for a specific `asset`. It enforces access control using `_checkRole(DEFAULT_ADMIN_ROLE)`. It checks if the `asset` is registered using `_checkRegisteredAsset`, reverting if not. It updates the `liquidationRates` mapping for the given `asset`. Emits the `LiquidationRateSet` event. Modifies `liquidationRates`. Reads `DEFAULT_ADMIN_ROLE`. Calls `_checkRole`, `_checkRegisteredAsset`."
  },
  "HoneyFactory.setMinSharesToRecapitalize": {
    "type": "external",
    "function_name": "setMinSharesToRecapitalize(uint256 minSharesAmount)",
    "analysis_result": "Allows the `DEFAULT_ADMIN_ROLE` to set the minimum number of shares a user must mint during a recapitalization action. It enforces access control using `_checkRole(DEFAULT_ADMIN_ROLE)`. It validates that `minSharesAmount` is not less than `DEFAULT_MIN_SHARES_TO_RECAPITALIZE` (1e18), reverting with `AmountOutOfRange` if below. It updates the `minSharesToRecapitalize` state variable. Emits the `MinSharesToRecapitalizeSet` event. Modifies `minSharesToRecapitalize`. Reads `DEFAULT_ADMIN_ROLE`, `DEFAULT_MIN_SHARES_TO_RECAPITALIZE`. Calls `_checkRole`."
  },
  "HoneyFactory.setRecapitalizeBalanceThreshold": {
    "type": "external",
    "function_name": "setRecapitalizeBalanceThreshold(address asset, uint256 target)",
    "analysis_result": "Allows the `DEFAULT_ADMIN_ROLE` to set the target balance (in asset token decimals) for a specific `asset`'s vault to trigger or complete recapitalization. It enforces access control using `_checkRole(DEFAULT_ADMIN_ROLE)`. It updates the `recapitalizeBalanceThreshold` mapping for the given `asset`. Emits the `RecapitalizeBalanceThresholdSet` event. Modifies `recapitalizeBalanceThreshold`. Reads `DEFAULT_ADMIN_ROLE`. Calls `_checkRole`. Note: Does not check if the asset is registered."
  },
  "HoneyFactory.setPriceOracle": {
    "type": "external",
    "function_name": "setPriceOracle(address priceOracle_)",
    "analysis_result": "Allows the `DEFAULT_ADMIN_ROLE` to replace the current price oracle contract. It enforces access control using `_checkRole(DEFAULT_ADMIN_ROLE)`. It validates that the new `priceOracle_` address is not zero, reverting with `ZeroAddress` if it is. It updates the `priceOracle` state variable. Emits the `PriceOracleSet` event. Modifies `priceOracle`. Reads `DEFAULT_ADMIN_ROLE`. Calls `_checkRole`."
  },
  "HoneyFactory.createVault": {
    "type": "external",
    "function_name": "createVault(address asset)",
    "analysis_result": "Allows any address to create and register a new Vault (ERC4626) for a specific `asset`. It internally calls `_createVault(asset)` (inherited from VaultAdmin) to deploy and initialize a new vault instance cloned from the beacon. If this is the first registered asset (`numRegisteredAssets() == 0`), it sets this `asset` as the `referenceCollateral`. It sets the `relativeCap` for the new asset to 100% (`ONE_HUNDRED_PERCENT_RATE`) and initial `mintRates` and `redeemRates` to `DEFAULT_MINT_REDEEM_RATE`. It performs an initial check using `isPegged(asset)` to ensure the asset is pegged immediately after setup, reverting with `NotPegged` if not. It then sets `lowerPegOffsets` and `upperPegOffsets` for the asset to `DEFAULT_PEG_OFFSET`. Returns the address of the newly created vault. Modifies `referenceCollateral` (conditionally), `relativeCap`, `mintRates`, `redeemRates`, `lowerPegOffsets`, `upperPegOffsets`, and state variables in VaultAdmin via `_createVault` (like `vaults`, `registeredAssets`, `numRegisteredAssets`). Calls `numRegisteredAssets`, `_createVault`, `isPegged`, `ERC20(asset).decimals` (via `_createVault`). Reverts if the asset is already registered or if it's not pegged immediately after creation."
  },
  "HoneyFactory.mint": {
    "type": "external",
    "function_name": "mint(address asset, uint256 amount, address receiver, bool expectBasketMode)",
    "analysis_result": "Allows a user to mint Honey by depositing collateral assets. It requires the `whenNotPaused` modifier. It checks if the `asset` is registered using `_checkRegisteredAsset`. It determines the actual basket mode status using `isBasketModeEnabled(true)` and reverts with `UnexpectedBasketModeStatus` if it doesn't match `expectBasketMode`. If not in basket mode, it checks if the asset is 'good' collateral (`_checkGoodCollateralAsset`) and `isPegged`, reverting if not. It calls `_mint` for the single asset. It then checks the global cap using `_isCappedGlobal(true, asset)`, reverting with `ExceedGlobalCap` if exceeded. If in basket mode, it gets asset weights using `_getWeights(false, true)`, calculates the proportional `amount` for each registered asset based on the provided `asset` and `amount`, and calls `_mint` for each registered asset in a loop, accumulating the total Honey minted. The `_mint` call internally handles relative cap checks (skipped in basket mode), deposits, fee distribution, and Honey minting. Returns the total `honeyToMint` amount. Reads `forcedBasketMode`, `registeredAssets`, `isBadCollateralAsset`, `vaults`, `globalCap`. Modifies state via `_mint` (vault balances, Honey supply, fee records). Calls `_checkRegisteredAsset`, `isBasketModeEnabled`, `_checkGoodCollateralAsset`, `isPegged`, `_mint`, `_isCappedGlobal`, `_getWeights`, `_lookupRegistrationIndex`, `ERC20(asset).decimals`, `vaults[].convertToAssets`. Reverts if paused, asset not registered, unexpected basket mode, asset is bad/depegged (non-basket), global cap exceeded (non-basket), or zero weight reference asset (basket)."
  },
  "HoneyFactory.redeem": {
    "type": "external",
    "function_name": "redeem(address asset, uint256 honeyAmount, address receiver, bool expectBasketMode)",
    "analysis_result": "Allows a user to redeem collateral assets by burning Honey. It requires the `whenNotPaused` modifier. It checks if the `asset` is registered using `_checkRegisteredAsset`. It determines the actual basket mode status using `isBasketModeEnabled(false)` and reverts with `UnexpectedBasketModeStatus` if it doesn't match `expectBasketMode`. If not in basket mode, it calls `_redeem` for the single asset. If the redeemed `asset` is the `referenceCollateral`, it checks all *other* registered assets to ensure they don't exceed their relative cap using `_isCappedRelative`, reverting with `ExceedRelativeCap` if any do. It then checks the global cap using `_isCappedGlobal(false, asset)`, reverting with `ExceedGlobalCap` if the check fails (allows reducing weight, prevents increasing weight of others). If in basket mode, it gets asset weights using `_getWeights(false, true)`, calculates the proportional `honeyAmount` for each registered asset, and calls `_redeem` for each registered asset in a loop, storing the redeemed amounts. The `_redeem` call internally handles burning Honey, calculating shares, fee distribution, and redeeming assets from the vault. Returns an array of redeemed asset amounts. Reads `forcedBasketMode`, `registeredAssets`, `isBadCollateralAsset`, `vaults`, `referenceCollateral`, `relativeCap`, `globalCap`. Modifies state via `_redeem` (Honey supply, vault balances, fee records). Calls `_checkRegisteredAsset`, `isBasketModeEnabled`, `_redeem`, `_lookupRegistrationIndex`, `_isCappedRelative`, `_isCappedGlobal`, `_getWeights`. Reverts if paused, asset not registered, unexpected basket mode, or cap checks fail."
  },
  "HoneyFactory.liquidate": {
    "type": "external",
    "function_name": "liquidate(address badCollateral, address goodCollateral, uint256 goodAmount)",
    "analysis_result": "Allows any address to liquidate 'bad' collateral using 'good' collateral. It requires the `whenNotPaused` modifier. It checks if both `badCollateral` and `goodCollateral` are registered using `_checkRegisteredAsset`. It checks if `goodCollateral` is 'good' using `_checkGoodCollateralAsset`. It checks if `liquidationEnabled` is true, reverting with `LiquidationDisabled` if not. It checks if `badCollateral` is marked as bad using `isBadCollateralAsset`, reverting with `AssetIsNotBadCollateral` if not. It prevents liquidation if `badCollateral` is the `referenceCollateral`, reverting with `LiquidationWithReferenceCollateral`. It deposits `goodAmount` of `goodCollateral` into its vault using `_approveAndDeposit`. It fetches prices for both assets using `_getPrice`. It calculates the theoretical amount of `badCollateral` shares to seize based on prices, deposited `goodShares`, and `liquidationRates`. It gets the actual available `badCollateral` shares using `_getSharesWithoutFees`. If the theoretical amount exceeds available shares, it adjusts the `goodShares` to be redeemed and refunds the excess `goodCollateral` to the liquidator using `_redeemShares`. It checks if the `goodCollateral` exceeds its relative cap using `_isCappedRelative`, reverting with `ExceedRelativeCap`. It checks if the `badCollateral` exceeds the global cap after the presumed reduction using `_isCappedGlobal(false, badCollateral)`, reverting with `ExceedGlobalCap`. It redeems the final `badAmount` of `badCollateral` shares and transfers the assets to the liquidator using `_redeemShares`. It checks invariants for both assets using `_checkInvariants`. Emits the `Liquidated` event. Returns the amount of `badAmount` redeemed. Reads `liquidationEnabled`, `isBadCollateralAsset`, `referenceCollateral`, `liquidationRates`, `relativeCap`, `globalCap`, `vaults`, `collectedAssetFees`. Modifies state via internal calls (vault balances, fee records). Calls `_checkRegisteredAsset`, `_checkGoodCollateralAsset`, `_approveAndDeposit`, `_getPrice`, `_getSharesWithoutFees`, `_redeemShares`, `_isCappedRelative`, `_isCappedGlobal`, `_checkInvariants`, `IPriceOracle.getPriceNoOlderThan`, `SafeTransferLib.safeTransferFrom`, `SafeTransferLib.safeApprove`, `vaults[].deposit`, `vaults[].redeem`, `vaults[].balanceOf`, `vaults[].convertToAssets`, `CollateralVault().custodyInfo`."
  },
  "HoneyFactory.recapitalize": {
    "type": "external",
    "function_name": "recapitalize(address asset, uint256 amount)",
    "analysis_result": "Allows any address to deposit `asset` into its vault to help it reach a target balance. It requires the `whenNotPaused` modifier. It checks if the `asset` is registered using `_checkRegisteredAsset` and is 'good' collateral using `_checkGoodCollateralAsset`. It gets the `targetBalance` from `recapitalizeBalanceThreshold`. It calculates the current vault balance (excluding fees) and reverts with `RecapitalizeNotNeeded` if it's already >= the target. It checks if the `asset` is `isPegged`, reverting with `NotPegged` if not. If `amount` would exceed the target, it limits the `amount` to reach exactly the target. It converts the `amount` to shares and checks if the shares amount is less than `minSharesToRecapitalize`, reverting with `InsufficientRecapitalizeAmount` if below. It deposits the adjusted `amount` using `_approveAndDeposit`. It checks if the `asset` exceeds its relative cap (`_isCappedRelative`) or the global cap (`_isCappedGlobal(true, asset)`) after deposit, reverting with `ExceedRelativeCap` or `ExceedGlobalCap` respectively. It checks invariants using `_checkInvariants`. Emits the `Recapitalized` event. Reads `recapitalizeBalanceThreshold`, `vaults`, `collectedAssetFees`, `minSharesToRecapitalize`, `relativeCap`, `globalCap`. Modifies state via `_approveAndDeposit` (vault balance). Calls `_checkRegisteredAsset`, `_checkGoodCollateralAsset`, `isPegged`, `vaults[].totalAssets`, `vaults[].convertToAssets`, `vaults[].convertToShares`, `_approveAndDeposit`, `_isCappedRelative`, `_isCappedGlobal`, `_checkInvariants`."
  },
  "HoneyFactory.isBasketModeEnabled": {
    "type": "public view",
    "function_name": "isBasketModeEnabled(bool isMint)",
    "analysis_result": "Determines if basket mode is currently active. It first checks `forcedBasketMode`. If true, returns true. Otherwise, it iterates through all `registeredAssets`. For mint (`isMint=true`), it returns false if it finds any asset that is both `isPegged` and *not* `isBadCollateralAsset`. If the loop finishes without finding such an asset, returns true. For redeem (`isMint=false`), it returns true if it finds any asset that is *not* `isPegged` and whose vault balance (excluding fees) is greater than 0 (`_getSharesWithoutFees > 0`). If the loop finishes without finding such an asset, returns false. Reads `forcedBasketMode`, `registeredAssets`, `isBadCollateralAsset`, `vaults`, `collectedAssetFees`. Calls `isPegged`, `_getSharesWithoutFees`."
  },
  "HoneyFactory.getWeights": {
    "type": "external view",
    "function_name": "getWeights()",
    "analysis_result": "Returns the calculated weights of all registered assets, normalized to sum to 1e18, excluding paused vaults. It calls the internal `_getWeights(false, true)`. Reads `registeredAssets`, `isBadCollateralAsset`, `vaults`, `collectedAssetFees`. Calls `_getWeights`, `_getSharesWithoutFees`, `vaults[].paused`."
  },
  "HoneyFactory.isPegged": {
    "type": "public view",
    "function_name": "isPegged(address asset)",
    "analysis_result": "Checks if a specific `asset` is considered pegged based on its price data from the `priceOracle`. Returns true if the price is available (`priceOracle.priceAvailable`), not stale (publish time within `priceFeedMaxDelay` seconds), and within the `lowerPegOffsets`/`upperPegOffsets` range from 1e18. Otherwise, returns false. Reads `priceOracle`, `priceFeedMaxDelay`, `lowerPegOffsets`, `upperPegOffsets`. Calls `priceOracle.priceAvailable`, `priceOracle.getPriceUnsafe`."
  },
  "HoneyFactory._mint": {
    "type": "internal",
    "function_name": "_mint(address asset, uint256 amount, address receiver, bool basketMode)",
    "analysis_result": "Internal function handling the core Honey minting process for a single asset. If `amount` is 0, returns 0. Deposits `amount` of `asset` into its vault using `_approveAndDeposit`, getting the minted `shares`. Calculates `honeyAmount` to mint and fee shares using `_getHoneyMintedFromShares`. Distributes fees using `_handleFees`. If not in `basketMode`, checks relative cap using `_isCappedRelative`, reverting with `ExceedRelativeCap` if exceeded. Mints `honeyAmount` to `receiver` using `honey.mint`. Checks invariants using `_checkInvariants`. Emits `HoneyMinted`. Returns `honeyAmount`. Reads `mintRates`, `polFeeCollectorFeeRate`, `relativeCap`, `referenceCollateral`, `vaults`, `collectedAssetFees`, `honey`. Modifies state via `_approveAndDeposit`, `_handleFees`, `honey.mint`."
  },
  "HoneyFactory._redeem": {
    "type": "internal",
    "function_name": "_redeem(address asset, uint256 honeyAmount, address receiver)",
    "analysis_result": "Internal function handling the core asset redemption process by burning Honey for a single asset. If `honeyAmount` is 0, returns 0. Calculates `shares` to redeem and fee shares using `_getSharesRedeemedFromHoney`. Burns `honeyAmount` from `msg.sender` using `honey.burn`. Distributes fees using `_handleFees`. Redeems `sharesForRedeem` from vault to `receiver` using `_redeemShares`. Checks invariants using `_checkInvariants`. Emits `HoneyRedeemed`. Returns redeemed asset amount. Reads `redeemRates`, `polFeeCollectorFeeRate`, `honey`, `vaults`, `collectedAssetFees`. Modifies state via `honey.burn`, `_handleFees`, `_redeemShares`."
  },
  "HoneyFactory._getHoneyMintedFromShares": {
    "type": "internal view",
    "function_name": "_getHoneyMintedFromShares(address asset, uint256 shares)",
    "analysis_result": "Calculates the amount of Honey to mint and the fee shares for POL and the fee receiver based on the deposited `shares` and the asset's `mintRate`. Reads `mintRates` and `polFeeCollectorFeeRate`. Performs calculations based on these values. Returns `honeyAmount`, `feeReceiverFeeShares`, `polFeeCollectorFeeShares`."
  },
  "HoneyFactory._getSharesRedeemedFromHoney": {
    "type": "internal view",
    "function_name": "_getSharesRedeemedFromHoney(address asset, uint256 honeyAmount)",
    "analysis_result": "Calculates the amount of shares to redeem and the fee shares for POL and the fee receiver based on the burned `honeyAmount` and the asset's `redeemRate`. Reads `redeemRates` and `polFeeCollectorFeeRate`. Performs calculations based on these values. Returns `shares`, `feeReceiverFeeShares`, `polFeeCollectorFeeShares`."
  },
  "HoneyFactory._getWeights": {
    "type": "internal view",
    "function_name": "_getWeights(bool filterBadCollaterals, bool filterPausedCollateral)",
    "analysis_result": "Calculates the relative weights of registered assets based on the factory's share holdings (excluding fees). Takes flags to filter bad collaterals and paused vaults. Iterates `registeredAssets`, skips filtered ones. Gets factory's shares using `_getSharesWithoutFees`. Sums unfiltered shares. If sum is 0, returns zero weights. Otherwise, normalizes non-filtered shares to sum to 1e18. Reads `registeredAssets`, `isBadCollateralAsset`, `vaults`, `collectedAssetFees`. Calls `_getSharesWithoutFees`, `vaults[].paused`."
  },
  "HoneyFactory._isCappedRelative": {
    "type": "internal view",
    "function_name": "_isCappedRelative(address asset)",
    "analysis_result": "Checks if the `asset`'s weight relative to the `referenceCollateral` exceeds its `relativeCap`. If `asset` is `referenceCollateral`, returns true. Gets factory shares (no fees) for both assets using `_getSharesWithoutFees`. If `referenceCollateral` shares are 0, returns true only if `asset` shares are also 0. Otherwise, calculates relative weight and compares to `relativeCap[asset]`. Reads `referenceCollateral`, `relativeCap`, `vaults`, `collectedAssetFees`. Calls `_getSharesWithoutFees`, `vaults[].balanceOf`."
  },
  "HoneyFactory._isCappedGlobal": {
    "type": "internal view",
    "function_name": "_isCappedGlobal(bool isMint, address collateralAsset)",
    "analysis_result": "Checks if any asset's weight exceeds the `globalCap`. Calculates weights using `_getWeights(true, false)`. For mint (`isMint=true`), checks only `collateralAsset`. For redeem (`isMint=false`), checks all assets except `collateralAsset`. Returns true if no relevant asset exceeds `globalCap`, false otherwise. Reads `globalCap`, `registeredAssets`, `isBadCollateralAsset`, `vaults`, `collectedAssetFees`. Calls `_getWeights`, `_getSharesWithoutFees`, `vaults[].paused`."
  },
  "HoneyFactory._getPrice": {
    "type": "internal view",
    "function_name": "_getPrice(address asset)",
    "analysis_result": "Fetches the price of the `asset` from the `priceOracle` using `getPriceNoOlderThan`, enforcing the `priceFeedMaxDelay`. Reads `priceOracle`, `priceFeedMaxDelay`. Calls `priceOracle.getPriceNoOlderThan`. Reverts if price is stale or unavailable (handled by oracle call)."
  },
  "HoneyFactory._getSharesWithoutFees": {
    "type": "internal view",
    "function_name": "_getSharesWithoutFees(address asset)",
    "analysis_result": "Calculates the factory's share balance in the asset's vault, excluding the shares designated as collected fees. Reads `vaults`, `collectedAssetFees`. Calls `vaults[asset].balanceOf`. Returns the share amount."
  },
  "HoneyFactory._approveAndDeposit": {
    "type": "internal",
    "function_name": "_approveAndDeposit(address asset, uint256 amount)",
    "analysis_result": "Handles asset transfer and vault deposit. Pulls `amount` of `asset` from `msg.sender` to the factory using `SafeTransferLib.safeTransferFrom`. Approves the asset's vault to spend this amount from the factory using `SafeTransferLib.safeApprove`. Deposits the `amount` into the vault using `vaults[asset].deposit`, receiving shares. Returns the shares received. Reads `vaults`. Calls `SafeTransferLib.safeTransferFrom`, `SafeTransferLib.safeApprove`, `vaults[].deposit`."
  },
  "HoneyFactory._redeemShares": {
    "type": "internal",
    "function_name": "_redeemShares(address asset, uint256 shares, address receiver)",
    "analysis_result": "Redeems `shares` from the asset's vault and sends the underlying assets to the `receiver`. Calls `vaults[asset].redeem(shares, receiver, address(this))`. Returns the amount of assets redeemed. Reads `vaults`. Calls `vaults[].redeem`."
  },
  "HoneyFactory._handleFees": {
    "type": "internal",
    "function_name": "_handleFees(address asset, uint256 polFeeCollectorFeeShares, uint256 feeReceiverFeeShares)",
    "analysis_result": "Distributes fee shares. If `polFeeCollectorFeeShares > 0`, redeems these shares to the `polFeeCollector` using `_redeemShares`. If `feeReceiverFeeShares > 0`, adds these shares to the `collectedFees` mapping for the `feeReceiver` and updates `collectedAssetFees[asset]`. Reads `polFeeCollector`. Modifies `collectedFees`, `collectedAssetFees`. Calls `_redeemShares`."
  },
  "HoneyFactory._checkInvariants": {
    "type": "internal view",
    "function_name": "_checkInvariants(address asset)",
    "analysis_result": "Checks crucial safety invariants for the vault. Asserts that `vault.convertToAssets(vault.totalSupply())` is less than or equal to the total underlying assets held by the vault or its custody address (`ERC20(asset).balanceOf(custodyAddress/vault address)`). Also asserts that the factory's vault share balance (`vault.balanceOf(address(this))`) is not less than the collected fees for that asset (`collectedAssetFees[asset]`). Reverts with `InsufficientAssets` if any invariant is violated. Reads `vaults`, `collectedAssetFees`. Calls `vaults[].totalSupply`, `CollateralVault().custodyInfo`, `ERC20(asset).balanceOf`, `vaults[].convertToAssets`, `vaults[].balanceOf`."
  },
  "CollateralVault.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "Purpose: Initializes the contract for upgradeability by disabling the standard constructor logic.\nLogic: Calls the internal `_disableInitializers()` function.\nVariables Used/Modified: None directly.\nExternal Calls: None.\nInternal Calls: `_disableInitializers()` (from OpenZeppelin upgradeable patterns).\nModifiers: None.\nEvents: None.\nConditions/Checks: None."
  },
  "CollateralVault.initialize": {
    "type": "external",
    "function_name": "initialize(address asset_, address _factory)",
    "analysis_result": "Purpose: Initializes the contract state variables after deployment, specific for upgradeable contracts.\nLogic: Delegates the initialization logic to the internal `__CollateralVault_init` function.\nVariables Used/Modified: None directly.\nExternal Calls: None.\nInternal Calls: `__CollateralVault_init(asset_, _factory)`.\nModifiers: `initializer` (Ensures this can only be called once after deployment).\nEvents: None.\nConditions/Checks: Implicit checks from the `initializer` modifier."
  },
  "CollateralVault.__CollateralVault_init": {
    "type": "internal",
    "function_name": "__CollateralVault_init(address asset_, address _factory)",
    "analysis_result": "Purpose: Sets the core configuration of the vault, including the underlying asset, factory address, name, and symbol.\nLogic: 1. Calls the initializer for the `PausableUpgradeable` base contract (`__Pausable_init()`). 2. Checks if the provided `_factory` address is zero; reverts with `ZeroAddress` error if it is. 3. Sets the `factory` state variable. 4. Creates an `ERC20` instance for the provided `asset_` address. 5. Sets the `_vaultAsset` state variable to the ERC20 instance address. 6. Retrieves the name and symbol from the underlying asset using external calls (`_asset.name()`, `_asset.symbol()`). 7. Concatenates \"Vault\" with the asset name and symbol to set the `_name` and `_symbol` state variables.\nVariables Used/Modified: `factory` (modified), `_vaultAsset` (modified), `_name` (modified), `_symbol` (modified).\nExternal Calls: `_asset.name()`, `_asset.symbol()` on the address provided as `asset_`.\nInternal Calls: `__Pausable_init()` (from `PausableUpgradeable`).\nModifiers: `onlyInitializing` (Ensures this can only be called during the initialization phase).\nEvents: None.\nConditions/Checks: Checks if `_factory == address(0)` and reverts with `ZeroAddress.selector.revertWith()`."
  },
  "CollateralVault.onlyFactory": {
    "type": "modifier",
    "function_name": "onlyFactory()",
    "analysis_result": "Purpose: Restricts the execution of a function to only the address stored in the `factory` state variable.\nLogic: Calls the internal helper function `_checkFactory()`.\nVariables Used/Modified: `factory` (read within `_checkFactory`).\nExternal Calls: None.\nInternal Calls: `_checkFactory()`.\nModifiers: None.\nEvents: None.\nConditions/Checks: The check `msg.sender != factory` is performed within the `_checkFactory` internal function. If true, it reverts with `NotFactory.selector.revertWith()`."
  },
  "CollateralVault.pause": {
    "type": "external",
    "function_name": "pause()",
    "analysis_result": "Purpose: Pauses the vault, preventing deposit, mint, withdraw, and redeem operations.\nLogic: Calls the internal `_pause()` function inherited from `PausableUpgradeable`.\nVariables Used/Modified: Internal pausable state (modified by `_pause`).\nExternal Calls: None.\nInternal Calls: `_pause()` (from `PausableUpgradeable`).\nModifiers: `onlyFactory` (Ensures only the factory can pause the vault).\nEvents: `Paused` (Emitted by `_pause`).\nConditions/Checks: Checked by the `onlyFactory` modifier."
  },
  "CollateralVault.unpause": {
    "type": "external",
    "function_name": "unpause()",
    "analysis_result": "Purpose: Unpauses the vault, allowing deposit, mint, withdraw, and redeem operations again.\nLogic: Calls the internal `_unpause()` function inherited from `PausableUpgradeable`.\nVariables Used/Modified: Internal pausable state (modified by `_unpause`).\nExternal Calls: None.\nInternal Calls: `_unpause()` (from `PausableUpgradeable`).\nModifiers: `onlyFactory` (Ensures only the factory can unpause the vault).\nEvents: `Unpaused` (Emitted by `_unpause`).\nConditions/Checks: Checked by the `onlyFactory` modifier."
  },
  "CollateralVault.deposit": {
    "type": "public",
    "function_name": "deposit(uint256 assets, address receiver)",
    "analysis_result": "Purpose: Allows the factory to deposit a specific amount of underlying `assets` into the vault and receive shares in return.\nLogic: Calls the `deposit` function of the base `ERC4626` contract (`super.deposit`). This function internally handles asset transfer, share calculation, and share minting.\nVariables Used/Modified: None directly, but modifies balances via `super.deposit`.\nExternal Calls: None directly. `super.deposit` will perform an external transfer of the underlying asset.\nInternal Calls: `super.deposit`, `_afterDeposit` (called by `super.deposit`).\nModifiers: `onlyFactory` (Restricts deposit to the factory), `whenNotPaused` (Requires the vault not to be paused).\nEvents: `Deposit` (Emitted by `super.deposit`).\nConditions/Checks: Checked by `onlyFactory` and `whenNotPaused` modifiers."
  },
  "CollateralVault.mint": {
    "type": "public",
    "function_name": "mint(uint256 shares, address receiver)",
    "analysis_result": "Purpose: Allows the factory to deposit the required amount of underlying assets to mint a specific amount of `shares`.\nLogic: Calls the `mint` function of the base `ERC4626` contract (`super.mint`). This function internally calculates required assets, handles asset transfer, and share minting.\nVariables Used/Modified: None directly, but modifies balances via `super.mint`.\nExternal Calls: None directly. `super.mint` will perform an external transfer of the underlying asset.\nInternal Calls: `super.mint`, `_afterDeposit` (called by `super.mint`).\nModifiers: `onlyFactory` (Restricts minting to the factory), `whenNotPaused` (Requires the vault not to be paused).\nEvents: `Deposit` (Emitted by `super.mint`).\nConditions/Checks: Checked by `onlyFactory` and `whenNotPaused` modifiers."
  },
  "CollateralVault.setCustodyInfo": {
    "type": "external",
    "function_name": "setCustodyInfo(bool _isCustodyVault, address _custodyAddress)",
    "analysis_result": "Purpose: Configures the custody setup for the vault, transferring assets to or from the specified custody address based on the configuration.\nLogic: 1. If `_isCustodyVault` is true, checks if `_custodyAddress` is zero; reverts with `ZeroAddress` if it is. 2. Reads the current `custodyInfo` state. 3. Checks two specific scenarios:\n   - If setting a new custody vault (`_isCustodyVault == true`) AND there is no existing custody (`_custodyInfo.custodyAddress == address(0)`): Transfers the entire current balance of the underlying asset from the vault to the `_custodyAddress` using `SafeTransferLib.safeTransfer`. Updates the `custodyInfo` state variable with the new configuration. Emits `CustodyInfoSet` event.\n   - If removing the custody feature (`_isCustodyVault == false`) AND the provided `_custodyAddress` matches the existing custody address (`_custodyInfo.custodyAddress == _custodyAddress`): Transfers the asset balance currently held by the custody address back to the vault using `SafeTransferLib.safeTransferFrom`. Updates the `custodyInfo` state variable, setting `isCustodyVault` to false and `custodyAddress` to `address(0)`. Emits `CustodyInfoSet` event.\n4. If neither of the above scenarios match (e.g., trying to change custody address without removing first, trying to remove custody with a wrong address), reverts with `InvalidCustodyInfoInput`.\nVariables Used/Modified: `custodyInfo` (read and modified), `_vaultAsset` (read indirectly via `asset()`).\nExternal Calls: `SafeTransferLib.safeTransfer`, `SafeTransferLib.safeTransferFrom`, `ERC20(asset()).balanceOf()`.\nInternal Calls: `asset()`.\nModifiers: `onlyFactory` (Restricts this configuration change to the factory).\nEvents: `CustodyInfoSet`.\nConditions/Checks: Checks `_isCustodyVault && _custodyAddress == address(0)`, checks current vs new `custodyInfo` states, reverts with `ZeroAddress` or `InvalidCustodyInfoInput`."
  },
  "CollateralVault.withdraw": {
    "type": "public",
    "function_name": "withdraw(uint256 assets, address receiver, address owner)",
    "analysis_result": "Purpose: Allows the factory to withdraw a specific amount of underlying `assets` from the vault on behalf of an `owner` and send them to a `receiver`.\nLogic: Calls the `withdraw` function of the base `ERC4626` contract (`super.withdraw`). This function internally handles share calculation, share burning, asset transfer, and potential custody interactions via `_beforeWithdraw`.\nVariables Used/Modified: None directly, but modifies balances via `super.withdraw`.\nExternal Calls: None directly. `super.withdraw` will perform an external transfer of the underlying asset.\nInternal Calls: `super.withdraw`, `_beforeWithdraw` (called by `super.withdraw`).\nModifiers: `onlyFactory` (Restricts withdrawal initiation to the factory), `whenNotPaused` (Requires the vault not to be paused).\nEvents: `Withdraw` (Emitted by `super.withdraw`).\nConditions/Checks: Checked by `onlyFactory` and `whenNotPaused` modifiers."
  },
  "CollateralVault.redeem": {
    "type": "public",
    "function_name": "redeem(uint256 shares, address receiver, address owner)",
    "analysis_result": "Purpose: Allows the factory to redeem a specific amount of `shares` from an `owner` and send the corresponding underlying assets to a `receiver`.\nLogic: Calls the `redeem` function of the base `ERC4626` contract (`super.redeem`). This function internally calculates assets, handles share burning, asset transfer, and potential custody interactions via `_beforeWithdraw`.\nVariables Used/Modified: None directly, but modifies balances via `super.redeem`.\nExternal Calls: None directly. `super.redeem` will perform an external transfer of the underlying asset.\nInternal Calls: `super.redeem`, `_beforeWithdraw` (called by `super.redeem`).\nModifiers: `onlyFactory` (Restricts redemption initiation to the factory), `whenNotPaused` (Requires the vault not to be paused).\nEvents: `Withdraw` (Emitted by `super.redeem`).\nConditions/Checks: Checked by `onlyFactory` and `whenNotPaused` modifiers."
  },
  "CollateralVault.name": {
    "type": "public",
    "function_name": "name()",
    "analysis_result": "Purpose: Returns the name of the vault token (shares).\nLogic: Returns the value stored in the `_name` state variable.\nVariables Used/Modified: `_name` (read).\nExternal Calls: None.\nInternal Calls: None.\nModifiers: None.\nEvents: None.\nConditions/Checks: None."
  },
  "CollateralVault.symbol": {
    "type": "public",
    "function_name": "symbol()",
    "analysis_result": "Purpose: Returns the symbol of the vault token (shares).\nLogic: Returns the value stored in the `_symbol` state variable.\nVariables Used/Modified: `_symbol` (read).\nExternal Calls: None.\nInternal Calls: None.\nModifiers: None.\nEvents: None.\nConditions/Checks: None."
  },
  "CollateralVault.asset": {
    "type": "public",
    "function_name": "asset()",
    "analysis_result": "Purpose: Returns the address of the underlying collateral asset managed by the vault.\nLogic: Returns the address stored in the `_vaultAsset` state variable.\nVariables Used/Modified: `_vaultAsset` (read).\nExternal Calls: None.\nInternal Calls: None.\nModifiers: None.\nEvents: None.\nConditions/Checks: None."
  },
  "CollateralVault.convertToAssets": {
    "type": "public",
    "function_name": "convertToAssets(uint256 shares)",
    "analysis_result": "Purpose: Converts an amount of vault `shares` into the corresponding amount of underlying assets, considering decimal differences.\nLogic: Delegates the conversion logic to the private internal function `_convertToAssets(shares)`.\nVariables Used/Modified: None directly.\nExternal Calls: None.\nInternal Calls: `_convertToAssets(shares)`.\nModifiers: None.\nEvents: None.\nConditions/Checks: None."
  },
  "CollateralVault.convertToShares": {
    "type": "public",
    "function_name": "convertToShares(uint256 assets)",
    "analysis_result": "Purpose: Converts an amount of underlying `assets` into the corresponding amount of vault shares, considering decimal differences.\nLogic: Delegates the conversion logic to the private internal function `_convertToShares(assets)`.\nVariables Used/Modified: None directly.\nExternal Calls: None.\nInternal Calls: `_convertToShares(assets)`.\nModifiers: None.\nEvents: None.\nConditions/Checks: None."
  },
  "CollateralVault.totalAssets": {
    "type": "public",
    "function_name": "totalAssets()",
    "analysis_result": "Purpose: Returns the total amount of underlying assets that represent the total supply of shares at a fixed exchange rate (1 share = 1 asset unit scaled by decimals).\nLogic: Calculates and returns the asset equivalent of the total vault shares supply (`totalSupply()`) by calling `_convertToAssets()`. This implementation explicitly sets the exchange rate to be based on the total supply, mitigating inflation attacks where assets might be directly transferred to the vault without minting shares.\nVariables Used/Modified: None directly, but reads `totalSupply` (from ERC20 base) and `_vaultAsset` (indirectly via `_convertToAssets`).\nExternal Calls: None.\nInternal Calls: `_convertToAssets()`, `totalSupply()` (from ERC20 base).\nModifiers: None.\nEvents: None.\nConditions/Checks: None."
  },
  "CollateralVault._initialConvertToShares": {
    "type": "internal",
    "function_name": "_initialConvertToShares(uint256 assets)",
    "analysis_result": "Purpose: ERC4626 hook to define the conversion from assets to shares when the vault is empty.\nLogic: Returns the result of converting `assets` to shares using the private internal function `_convertToShares`. This ensures the same decimal-adjusted 1:1 exchange rate is used even for the very first deposit.\nVariables Used/Modified: None.\nExternal Calls: None.\nInternal Calls: `_convertToShares(assets)`.\nModifiers: None.\nEvents: None.\nConditions/Checks: None."
  },
  "CollateralVault._initialConvertToAssets": {
    "type": "internal",
    "function_name": "_initialConvertToAssets(uint256 shares)",
    "analysis_result": "Purpose: ERC4626 hook to define the conversion from shares to assets when the vault is empty.\nLogic: Returns the result of converting `shares` to assets using the private internal function `_convertToAssets`. This ensures the same decimal-adjusted 1:1 exchange rate is used even when calculating assets for shares in an empty vault.\nVariables Used/Modified: None.\nExternal Calls: None.\nInternal Calls: `_convertToAssets(shares)`.\nModifiers: None.\nEvents: None.\nConditions/Checks: None."
  },
  "CollateralVault._convertToShares": {
    "type": "private",
    "function_name": "_convertToShares(uint256 assets)",
    "analysis_result": "Purpose: Converts an amount of underlying assets into the corresponding amount of vault shares, strictly based on the decimal difference.\nLogic: 1. Reads the decimals of the vault token (`decimals()`) and the underlying asset (`_vaultAsset.decimals()`). 2. Calculates the difference in decimals (`exponent`). 3. If vault decimals are greater than or equal to asset decimals, multiplies the asset amount by 10 to the power of the exponent. 4. If asset decimals are greater than vault decimals, divides the asset amount by 10 to the power of the exponent. Uses `unchecked` arithmetic for the power calculation.\nVariables Used/Modified: `_vaultAsset` (read for decimals).\nExternal Calls: `_vaultAsset.decimals()`.\nInternal Calls: `decimals()` (from ERC20 base).\nModifiers: None.\nEvents: None.\nConditions/Checks: None (uses unchecked arithmetic for scaling)."
  },
  "CollateralVault._convertToAssets": {
    "type": "private",
    "function_name": "_convertToAssets(uint256 shares)",
    "analysis_result": "Purpose: Converts an amount of vault shares into the corresponding amount of underlying assets, strictly based on the decimal difference.\nLogic: 1. Reads the decimals of the vault token (`decimals()`) and the underlying asset (`_vaultAsset.decimals()`). 2. Calculates the difference in decimals (`exponent`). 3. If vault decimals are greater than or equal to asset decimals, divides the share amount by 10 to the power of the exponent. 4. If asset decimals are greater than vault decimals, multiplies the share amount by 10 to the power of the exponent. Uses `unchecked` arithmetic for the power calculation.\nVariables Used/Modified: `_vaultAsset` (read for decimals).\nExternal Calls: `_vaultAsset.decimals()`.\nInternal Calls: `decimals()` (from ERC20 base).\nModifiers: None.\nEvents: None.\nConditions/Checks: None (uses unchecked arithmetic for scaling)."
  },
  "CollateralVault._useVirtualShares": {
    "type": "internal",
    "function_name": "_useVirtualShares()",
    "analysis_result": "Purpose: ERC4626 hook to indicate whether the vault uses virtual shares.\nLogic: Returns `false`, indicating that this vault does not utilize the virtual shares mechanism.\nVariables Used/Modified: None.\nExternal Calls: None.\nInternal Calls: None.\nModifiers: None.\nEvents: None.\nConditions/Checks: None."
  },
  "CollateralVault._requireNotPaused": {
    "type": "internal",
    "function_name": "_requireNotPaused()",
    "analysis_result": "Purpose: Internal PausableUpgradeable hook to check if the contract is currently paused and revert if it is.\nLogic: Calls the internal `paused()` function. If `paused()` returns true, it reverts execution with the `VaultPaused` error, including the asset address (though `asset()` might revert here if `_vaultAsset` is not set during initialization, which shouldn't happen in a valid flow).\nVariables Used/Modified: Internal pausable state (read via `paused()`), `_vaultAsset` (read via `asset()`).\nExternal Calls: None.\nInternal Calls: `paused()` (from `PausableUpgradeable`), `asset()`.\nModifiers: None.\nEvents: None.\nConditions/Checks: Checks `paused()`, reverts with `VaultPaused.selector.revertWith(asset())` if true."
  },
  "CollateralVault._checkFactory": {
    "type": "internal",
    "function_name": "_checkFactory()",
    "analysis_result": "Purpose: Internal helper function used by the `onlyFactory` modifier to verify the caller is the factory.\nLogic: Compares `msg.sender` with the `factory` state variable. If they are not equal, execution is reverted with the `NotFactory` error.\nVariables Used/Modified: `factory` (read).\nExternal Calls: None.\nInternal Calls: None.\nModifiers: None.\nEvents: None.\nConditions/Checks: Checks `msg.sender != factory`, reverts with `NotFactory.selector.revertWith()` if true."
  },
  "CollateralVault._afterDeposit": {
    "type": "internal",
    "function_name": "_afterDeposit(uint256 assets, uint256)",
    "analysis_result": "Purpose: ERC4626 hook executed after a deposit is completed.\nLogic: Checks if the vault is configured as a custody vault (`custodyInfo.isCustodyVault`). If it is, it transfers the deposited `assets` amount from the vault's address to the address stored in `custodyInfo.custodyAddress` using `SafeTransferLib.safeTransfer`.\nVariables Used/Modified: `custodyInfo` (read).\nExternal Calls: `SafeTransferLib.safeTransfer()`.\nInternal Calls: `asset()`.\nModifiers: None.\nEvents: None.\nConditions/Checks: Checks `custodyInfo.isCustodyVault`."
  },
  "CollateralVault._beforeWithdraw": {
    "type": "internal",
    "function_name": "_beforeWithdraw(uint256 assets, uint256)",
    "analysis_result": "Purpose: ERC4626 hook executed before a withdrawal or redemption is processed.\nLogic: Checks if the vault is configured as a custody vault (`custodyInfo.isCustodyVault`). If it is, it pulls the requested `assets` amount from the address stored in `custodyInfo.custodyAddress` to the vault's address using `SafeTransferLib.safeTransferFrom`.\nVariables Used/Modified: `custodyInfo` (read).\nExternal Calls: `SafeTransferLib.safeTransferFrom()`.\nInternal Calls: `asset()`.\nModifiers: None.\nEvents: None.\nConditions/Checks: Checks `custodyInfo.isCustodyVault`."
  },
  "VaultAdmin.__VaultAdmin_init": {
    "type": "internal",
    "function_name": "__VaultAdmin_init(address _governance, address _polFeeCollector, address _feeReceiver, address _beacon)",
    "analysis_result": "This is the main initializer function for the VaultAdmin contract, intended to be called only once during deployment or upgrade. It first calls the initializers of its inherited contracts: AccessControlUpgradeable, PausableUpgradeable, and UUPSUpgradeable. It then calls `__VaultAdmin_init_unchained` to perform its specific initialization logic. Finally, it sets the admin role for the PAUSER_ROLE to the MANAGER_ROLE, allowing MANAGERs to manage PAUSER permissions. It utilizes the `onlyInitializing` modifier from OpenZeppelin's Initializable contract to ensure it can only be called during the initialization process."
  },
  "VaultAdmin.__VaultAdmin_init_unchained": {
    "type": "internal",
    "function_name": "__VaultAdmin_init_unchained(address _governance, address _polFeeCollector, address _feeReceiver, address _beacon)",
    "analysis_result": "This function performs the core initialization logic for the VaultAdmin contract. It requires the input addresses (`_governance`, `_polFeeCollector`, `_feeReceiver`, `_beacon`) to be non-zero using `ZeroAddress.selector.revertWith()`. It sets the `beacon` state variable to the provided `_beacon` address. It grants the `DEFAULT_ADMIN_ROLE` to the `_governance` address. It sets the `feeReceiver` state variable to `_feeReceiver` and the `polFeeCollector` state variable to `_polFeeCollector`. It emits `FeeReceiverSet` and `POLFeeCollectorSet` events with the respective addresses. It is called by `__VaultAdmin_init` and also uses the `onlyInitializing` modifier."
  },
  "VaultAdmin._checkRegisteredAsset": {
    "type": "internal view",
    "function_name": "_checkRegisteredAsset(address asset)",
    "analysis_result": "This internal helper function checks if a vault exists for a given `asset` address. It reads the `vaults` mapping, using the `asset` address as the key. If the address stored in `vaults[asset]` is the zero address (meaning no vault is registered for this asset), it reverts the transaction using `AssetNotRegistered.selector.revertWith()` with the asset address. This function is used as a precondition in several other functions that operate on specific assets or vaults."
  },
  "VaultAdmin._checkGoodCollateralAsset": {
    "type": "internal view",
    "function_name": "_checkGoodCollateralAsset(address asset)",
    "analysis_result": "This internal helper function checks if an asset is NOT marked as bad collateral. It reads the `isBadCollateralAsset` mapping, using the `asset` address as the key. If `isBadCollateralAsset[asset]` is true, it means the asset is marked as bad collateral, and the function reverts the transaction using `AssetIsBadCollateral.selector.revertWith()` with the asset address. This function is likely intended to be used as a precondition for operations that require assets to be considered 'good' collateral, although it is currently unused within this specific contract snippet."
  },
  "VaultAdmin._authorizeUpgrade": {
    "type": "internal virtual override",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This internal function is part of the UUPS (Universal Upgradeable Proxy Standard) pattern and is called by the `UUPSUpgradeable` base contract during an upgrade attempt. Its purpose is to implement the authorization logic for upgrades. In this implementation, it simply checks if the caller has the `DEFAULT_ADMIN_ROLE` using `_checkRole(DEFAULT_ADMIN_ROLE)`. If the caller has this role, the upgrade is authorized. The `newImplementation` parameter is marked as `// Silent warning` and is not used within the function body."
  },
  "VaultAdmin.pause": {
    "type": "external",
    "function_name": "pause()",
    "analysis_result": "This external function pauses the contract, preventing calls to functions protected by the `whenNotPaused` modifier. It first checks if the caller has the `PAUSER_ROLE` using `_checkRole(PAUSER_ROLE)`. If the caller has the required role, it calls the internal `_pause()` function provided by the `PausableUpgradeable` base contract, which sets the contract's pause status to true and emits a `Paused` event."
  },
  "VaultAdmin.unpause": {
    "type": "external",
    "function_name": "unpause()",
    "analysis_result": "This external function unpauses the contract, allowing calls to functions protected by the `whenNotPaused` modifier. It first checks if the caller has the `MANAGER_ROLE` using `_checkRole(MANAGER_ROLE)`. If the caller has the required role, it calls the internal `_unpause()` function provided by the `PausableUpgradeable` base contract, which sets the contract's pause status to false and emits an `Unpaused` event."
  },
  "VaultAdmin.pauseVault": {
    "type": "external",
    "function_name": "pauseVault(address asset)",
    "analysis_result": "This external function pauses a specific collateral vault associated with the given `asset`. It first checks if the caller has the `PAUSER_ROLE` using `_checkRole(PAUSER_ROLE)`. It then calls the internal helper `_checkRegisteredAsset(asset)` to ensure a vault exists for the provided `asset`. If both checks pass, it retrieves the vault address from the `vaults` mapping and calls the `pause()` function on the `CollateralVault` instance. This allows pausing individual vaults without pausing the entire VaultAdmin contract."
  },
  "VaultAdmin.unpauseVault": {
    "type": "external",
    "function_name": "unpauseVault(address asset)",
    "analysis_result": "This external function unpauses a specific collateral vault associated with the given `asset`. It first checks if the caller has the `MANAGER_ROLE` using `_checkRole(MANAGER_ROLE)`. It then calls the internal helper `_checkRegisteredAsset(asset)` to ensure a vault exists for the provided `asset`. If both checks pass, it retrieves the vault address from the `vaults` mapping and calls the `unpause()` function on the `CollateralVault` instance. This allows unpausing individual vaults."
  },
  "VaultAdmin.setCustodyInfo": {
    "type": "external",
    "function_name": "setCustodyInfo(address asset, bool isCustodyVault, address custodyAddress)",
    "analysis_result": "This external function sets the custody information for a specific collateral vault. It first checks if the caller has the `DEFAULT_ADMIN_ROLE` using `_checkRole(DEFAULT_ADMIN_ROLE)`. It then calls the internal helper `_checkRegisteredAsset(asset)` to ensure a vault exists for the provided `asset`. If both checks pass, it retrieves the vault address from the `vaults` mapping and calls the `setCustodyInfo(bool, address)` function on the `CollateralVault` instance, passing the `isCustodyVault` and `custodyAddress` parameters. This allows the admin to configure whether a vault is managed by a custody address and set that address."
  },
  "VaultAdmin._createVault": {
    "type": "internal",
    "function_name": "_createVault(address asset) returns (CollateralVault)",
    "analysis_result": "This internal function creates and registers a new CollateralVault for a given `asset`. It requires the caller to have the `DEFAULT_ADMIN_ROLE` using `_checkRole(DEFAULT_ADMIN_ROLE)`. It checks if a vault for the `asset` is already registered by reading the `vaults` mapping; if `vaults[asset]` is not the zero address, it reverts with `VaultAlreadyRegistered.selector.revertWith()`. If no vault exists, it adds the `asset` to the `registeredAssets` array. It then deterministically deploys a new beacon proxy using `LibClone.deployDeterministicERC1967BeaconProxy`. The salt for the deterministic deployment is derived from the lower 160 bits of the `asset` address. It initializes the deployed vault by calling its `initialize` function with the `asset` address and the address of the VaultAdmin contract itself. It stores the address of the newly created vault in the `vaults` mapping for the given `asset`. Finally, it emits a `VaultCreated` event with the addresses of the new vault and the asset, and returns the `CollateralVault` instance. This function modifies `registeredAssets` and `vaults` state variables."
  },
  "VaultAdmin.setFeeReceiver": {
    "type": "external",
    "function_name": "setFeeReceiver(address _feeReceiver)",
    "analysis_result": "This external function sets the address where collected fees will be sent. It requires the caller to have the `DEFAULT_ADMIN_ROLE` using `_checkRole(DEFAULT_ADMIN_ROLE)`. It checks if the provided `_feeReceiver` address is the zero address, reverting with `ZeroAddress.selector.revertWith()` if it is. If the address is valid, it updates the `feeReceiver` state variable to the new address. It emits a `FeeReceiverSet` event with the new fee receiver address. This function modifies the `feeReceiver` state variable."
  },
  "VaultAdmin.setPOLFeeCollector": {
    "type": "external",
    "function_name": "setPOLFeeCollector(address _polFeeCollector)",
    "analysis_result": "This external function sets the address designated as the POL (Protocol Owned Liquidity) Fee Collector. It requires the caller to have the `DEFAULT_ADMIN_ROLE` using `_checkRole(DEFAULT_ADMIN_ROLE)`. It checks if the provided `_polFeeCollector` address is the zero address, reverting with `ZeroAddress.selector.revertWith()` if it is. If the address is valid, it updates the `polFeeCollector` state variable to the new address. It emits a `POLFeeCollectorSet` event with the new POL Fee Collector address. This function modifies the `polFeeCollector` state variable."
  },
  "VaultAdmin.setCollateralAssetStatus": {
    "type": "external",
    "function_name": "setCollateralAssetStatus(address asset, bool _isBadCollateral)",
    "analysis_result": "This external function sets the bad collateral status for a registered asset. If set to true, certain operations (like minting, potentially handled in the vault) might be disabled for that asset. It requires the caller to have the `MANAGER_ROLE` using `_checkRole(MANAGER_ROLE)`. It checks if the `asset` is registered using `_checkRegisteredAsset(asset)`. If both checks pass, it updates the `isBadCollateralAsset` mapping for the given `asset` with the provided `_isBadCollateral` boolean value. It emits a `CollateralAssetStatusSet` event with the asset address and its new status. This function modifies the `isBadCollateralAsset` state variable."
  },
  "VaultAdmin.withdrawAllFees": {
    "type": "external",
    "function_name": "withdrawAllFees(address receiver)",
    "analysis_result": "This external function allows a specific `receiver` to withdraw all collected fees accumulated across all registered assets. It iterates through the `registeredAssets` array using a for loop based on the number of registered assets (`numRegisteredAssets()`). For each registered `asset`, it calls the internal `_withdrawCollectedFee(address, address)` function, passing the current asset and the `receiver` address. This function is designed for a receiver to claim all their pending fees in one transaction, potentially across multiple assets, by triggering the withdrawal process for each registered asset they might have fees for. It implicitly relies on the `_withdrawCollectedFee` function to handle the actual redemption and transfer logic. It uses unchecked arithmetic for the loop counter `i` for gas optimization."
  },
  "VaultAdmin.withdrawFee": {
    "type": "external",
    "function_name": "withdrawFee(address asset, address receiver) returns (uint256 assets)",
    "analysis_result": "This external function allows a specific `receiver` to withdraw collected fees for a particular `asset`. It first checks if the `asset` is registered using `_checkRegisteredAsset(asset)`. If the asset is registered, it calls the internal `_withdrawCollectedFee(address, address)` function, passing the `asset` and `receiver` addresses. It returns the amount of assets withdrawn, which is the return value of the internal withdrawal function. This function provides a way to claim fees on an asset-by-asset basis."
  },
  "VaultAdmin._withdrawCollectedFee": {
    "type": "internal",
    "function_name": "_withdrawCollectedFee(address asset, address receiver) returns (uint256 assets)",
    "analysis_result": "This internal function handles the core logic for withdrawing collected fees for a specific `asset` and `receiver`. It reads the amount of fee shares owed to the `receiver` for the given `asset` from the `collectedFees[receiver][asset]` mapping. It first checks if the amount of shares, when converted to assets using `vaults[asset].convertToAssets(shares)`, is non-zero. If it's zero, it means there are no meaningful fees to withdraw, and the function returns 0. If there are shares, it resets `collectedFees[receiver][asset]` to 0. It then subtracts the withdrawn shares from the total collected shares for that asset, stored in `collectedAssetFees[asset]`. This subtraction is considered safe because `collectedFees[receiver][asset]` is part of `collectedAssetFees[asset]`. It then calls the `redeem(uint256 shares, address receiver, address owner)` function on the corresponding `CollateralVault` instance, asking the vault to redeem the shares owned by the `receiver` and transfer the resulting assets to the `receiver`. The owner parameter is set to `address(this)` (the VaultAdmin contract), as the shares might have been accounted for here. The amount of assets received from the vault is stored and returned. Finally, it emits a `CollectedFeeWithdrawn` event with the asset, receiver, shares, and assets withdrawn. This function modifies the `collectedFees` and `collectedAssetFees` state variables and calls the `convertToAssets` and `redeem` functions on a `CollateralVault` instance."
  },
  "VaultAdmin.numRegisteredAssets": {
    "type": "public view",
    "function_name": "numRegisteredAssets() returns (uint256)",
    "analysis_result": "This public view function returns the total number of registered assets. It simply returns the current length of the `registeredAssets` dynamic array, which is a state variable holding the addresses of all assets for which vaults have been created. It reads the `registeredAssets` state variable."
  },
  "VaultAdmin._lookupRegistrationIndex": {
    "type": "internal view",
    "function_name": "_lookupRegistrationIndex(address asset) returns (uint256 index)",
    "analysis_result": "This internal view function attempts to find the index of a given `asset` within the `registeredAssets` array. It iterates through the array from index 0 up to its current length (`registeredAssets.length`). Inside the loop, it compares each element (`registeredAssets[i]`) with the input `asset` address. If a match is found, it immediately returns the current index `i`. If the loop completes without finding a match (meaning the asset is not in the array), the function would implicitly return the default value for uint256, which is 0, though this return value should not be relied upon to indicate 'not found' as index 0 is a valid index. Note that this function is currently unused within the provided contract code."
  },
  "HoneyDeployer.constructor": {
    "type": "constructor",
    "function_name": "constructor(address governance, address polFeeCollector, address feeReceiver, uint256 honeySalt, uint256 honeyFactorySalt, uint256 honeyFactoryReaderSalt, address priceOracle)",
    "analysis_result": "This is the constructor of the HoneyDeployer contract. It is executed only once upon contract deployment. Its primary purpose is to deploy and initialize the core components of the Honey protocol: the Honey token proxy, the HoneyFactory proxy, the HoneyFactoryReader proxy, and a UpgradeableBeacon for CollateralVaults.\n\nLogic:\n1.  A new instance of `CollateralVault` is created, which will serve as the implementation contract for vaults managed by the `UpgradeableBeacon`.\n2.  A new `UpgradeableBeacon` is deployed, initialized with the provided `governance` address and the address of the newly created `CollateralVault` implementation.\n3.  The `Honey` implementation contract's bytecode (`type(Honey).creationCode`) is deployed using the inherited `deployWithCreate2` function with a salt of `0`. The returned address is stored temporarily.\n4.  A proxy contract for `Honey` is deployed using the inherited `deployProxyWithCreate2` function, taking the `honeyImpl` address and the provided `honeySalt` as arguments. The resulting proxy address is stored in the `immutable honey` state variable.\n5.  The `HoneyFactory` implementation contract's bytecode (`type(HoneyFactory).creationCode`) is deployed using `deployWithCreate2` with a salt of `0`. The returned address is stored temporarily.\n6.  A proxy contract for `HoneyFactory` is deployed using `deployProxyWithCreate2`, taking the `honeyFactoryImpl` address and the provided `honeyFactorySalt` as arguments. The resulting proxy address is stored in the `immutable honeyFactory` state variable.\n7.  The `HoneyFactoryReader` implementation contract's bytecode (`type(HoneyFactoryReader).creationCode`) is deployed using `deployWithCreate2` with a salt of `0`. The returned address is stored temporarily.\n8.  A proxy contract for `HoneyFactoryReader` is deployed using `deployProxyWithCreate2`, taking the `honeyFactoryReaderImpl` address and the provided `honeyFactoryReaderSalt` as arguments. The resulting proxy address is stored in the `immutable honeyFactoryReader` state variable.\n9.  The deployed proxy contracts are initialized by calling their respective `initialize` functions:\n    *   `honey.initialize()` is called with `governance` and the address of the deployed `honeyFactory` proxy.\n    *   `honeyFactory.initialize()` is called with `governance`, the address of the deployed `honey` proxy, `polFeeCollector`, `feeReceiver`, `priceOracle`, and the address of the deployed `beacon`.\n    *   `honeyFactoryReader.initialize()` is called with `governance` and the address of the deployed `honeyFactory` proxy.\n\nVariables Used:\n- Parameters: `governance` (address for access control), `polFeeCollector` (address for fee collection), `feeReceiver` (address receiving fees), `honeySalt` (salt for deterministic Honey proxy deployment), `honeyFactorySalt` (salt for deterministic HoneyFactory proxy deployment), `honeyFactoryReaderSalt` (salt for deterministic HoneyFactoryReader proxy deployment), `priceOracle` (address of the price oracle).\n- State Variables: `honey` (immutable address, assigned Honey proxy address), `honeyFactory` (immutable address, assigned HoneyFactory proxy address), `honeyFactoryReader` (immutable address, assigned HoneyFactoryReader proxy address).\n\nCalls Made:\n- `new UpgradeableBeacon(...)`: Deploys a new UpgradeableBeacon contract.\n- `new CollateralVault()`: Deploys a new CollateralVault implementation contract.\n- `deployWithCreate2(...)`: Internal/inherited function to deploy implementation contracts deterministically.\n- `deployProxyWithCreate2(...)`: Internal/inherited function to deploy proxy contracts deterministically.\n- `honey.initialize(...)`: External call to the deployed Honey proxy's initialize function.\n- `honeyFactory.initialize(...)`: External call to the deployed HoneyFactory proxy's initialize function.\n- `honeyFactoryReader.initialize(...)`: External call to the deployed HoneyFactoryReader proxy's initialize function.\n\nState Variables Modified:\n- `honey`, `honeyFactory`, `honeyFactoryReader` are assigned their respective proxy contract addresses during deployment. Since they are immutable, these are the only modifications possible.\n\nDependencies:\n- Inherits from `Create2Deployer` for deployment logic.\n- Depends on the availability and expected `initialize` function signatures of `UpgradeableBeacon`, `CollateralVault`, `Honey`, `HoneyFactory`, and `HoneyFactoryReader`."
  },
  "BeraChef_V0.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor of the contract. It is marked with `_disableInitializers()` which is a pattern used in upgradeable contracts (UUPS) to prevent the `initialize` function from being called directly upon deployment. It ensures that the contract must be initialized via the proxy's `initialize` call."
  },
  "BeraChef_V0.initialize": {
    "type": "external",
    "function_name": "initialize(address _distributor, address _factory, address _governance, address _beaconDepositContract, uint8 _maxNumWeightsPerRewardAllocation)",
    "analysis_result": "This function is the initializer for the upgradeable contract, called once after deployment via the proxy. It takes addresses for the distributor, factory, governance (owner), beacon deposit contract, and a uint8 for the maximum number of weights allowed per reward allocation. It initializes the `OwnableUpgradeable` and `UUPSUpgradeable` base contracts using `__Ownable_init` and `__UUPSUpgradeable_init`, setting the contract owner to `_governance`. It assigns the provided addresses to the storage variables `distributor`, `factory`, and `beaconDepositContract`. It checks if `_maxNumWeightsPerRewardAllocation` is zero and reverts if it is, using `MaxNumWeightsPerRewardAllocationIsZero.selector.revertWith()`. Otherwise, it sets the storage variable `maxNumWeightsPerRewardAllocation` to the provided value and emits the `MaxNumWeightsPerRewardAllocationSet` event. This function is crucial for setting up the core dependencies and parameters of the BeraChef contract."
  },
  "BeraChef_V0._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This is an internal function required by the `UUPSUpgradeable` pattern. It is called by the proxy to determine if the current contract instance is authorized to upgrade to a new implementation at `newImplementation`. The implementation provided here is simple: it only allows the upgrade if the caller is the contract owner, leveraging the `onlyOwner` modifier internally by the `UUPSUpgradeable` base contract logic before calling this hook. It does not access or modify any specific storage variables of the `BeraChef_V0` contract itself."
  },
  "BeraChef_V0.onlyDistributor": {
    "type": "modifier",
    "function_name": "onlyDistributor()",
    "analysis_result": "This is a custom modifier that restricts function access to only the address stored in the `distributor` storage variable. It checks if `msg.sender` is equal to `distributor`. If not, it reverts with `NotDistributor.selector.revertWith()`. It uses the storage variable `distributor`."
  },
  "BeraChef_V0.onlyOperator": {
    "type": "modifier",
    "function_name": "onlyOperator(bytes calldata valPubkey)",
    "analysis_result": "This is a custom modifier that restricts function access to only the operator associated with the provided validator public key (`valPubkey`). It calls the `getOperator` function on the `beaconDepositContract` storage variable, passing `valPubkey` as the argument. It then checks if `msg.sender` is equal to the address returned by `getOperator`. If not, it reverts with `NotOperator.selector.revertWith()`. It uses the storage variable `beaconDepositContract` and the input parameter `valPubkey`."
  },
  "BeraChef_V0.setMaxNumWeightsPerRewardAllocation": {
    "type": "external",
    "function_name": "setMaxNumWeightsPerRewardAllocation(uint8 _maxNumWeightsPerRewardAllocation)",
    "analysis_result": "This function allows the contract owner to set the maximum number of weights allowed in a single reward allocation. It is restricted to the contract owner via the `onlyOwner` modifier inherited from `OwnableUpgradeable`. It takes a `uint8` `_maxNumWeightsPerRewardAllocation` as input. It checks if the input value is zero and reverts with `MaxNumWeightsPerRewardAllocationIsZero.selector.revertWith()` if it is. It then checks if the new maximum is less than the current number of weights in the `defaultRewardAllocation` storage variable. If it is, it means changing the max would invalidate the current default, so it reverts with `InvalidateDefaultRewardAllocation.selector.revertWith()`. If the checks pass, it updates the `maxNumWeightsPerRewardAllocation` storage variable and emits the `MaxNumWeightsPerRewardAllocationSet` event. It uses the storage variables `maxNumWeightsPerRewardAllocation` and `defaultRewardAllocation`."
  },
  "BeraChef_V0.setRewardAllocationBlockDelay": {
    "type": "external",
    "function_name": "setRewardAllocationBlockDelay(uint64 _rewardAllocationBlockDelay)",
    "analysis_result": "This function allows the contract owner to set the minimum block delay required before a queued reward allocation can become active. It is restricted to the contract owner via the `onlyOwner` modifier. It takes a `uint64` `_rewardAllocationBlockDelay` as input. It checks if the input value is greater than `MAX_REWARD_ALLOCATION_BLOCK_DELAY` constant and reverts with `RewardAllocationBlockDelayTooLarge.selector.revertWith()` if it is. Otherwise, it updates the `rewardAllocationBlockDelay` storage variable with the new value and emits the `RewardAllocationBlockDelaySet` event. It uses the storage variable `rewardAllocationBlockDelay`."
  },
  "BeraChef_V0.setVaultWhitelistedStatus": {
    "type": "external",
    "function_name": "setVaultWhitelistedStatus(address receiver, bool isWhitelisted, string memory metadata)",
    "analysis_result": "This function allows the contract owner to add or remove an address (`receiver`) from the list of whitelisted reward vaults. It is restricted to the contract owner via the `onlyOwner` modifier. It takes an `address` `receiver`, a `bool` `isWhitelisted`, and a `string` `metadata` as input. Before updating the status, it verifies that the `receiver` address is a valid vault created by the `factory`. It calls `getVault` on the `factory` contract (casted to `IRewardVaultFactory_V0`) using the `stakeToken` address obtained by calling `stakeToken()` on the `receiver` address (casted to `RewardVault_V0`). If the returned factory vault address does not match `receiver`, it reverts with `NotFactoryVault.selector.revertWith()`. It then updates the `isWhitelistedVault` storage mapping for the `receiver` address with the `isWhitelisted` status. If the vault is being *de-whitelisted* (`!isWhitelisted`), it calls the internal function `_checkIfStillValid` with the weights of the `defaultRewardAllocation` storage variable to ensure the default allocation remains valid. If `_checkIfStillValid` returns false, it means the default allocation contains the vault being de-whitelisted, which is not allowed, and it reverts with `InvalidRewardAllocationWeights.selector.revertWith()`. Finally, it emits the `VaultWhitelistedStatusUpdated` event with the receiver, new status, and metadata. It uses the storage variables `isWhitelistedVault`, `factory`, and `defaultRewardAllocation`."
  },
  "BeraChef_V0.updateWhitelistedVaultMetadata": {
    "type": "external",
    "function_name": "updateWhitelistedVaultMetadata(address vault, string memory metadata)",
    "analysis_result": "This function allows the contract owner to update the metadata associated with an existing whitelisted vault. It is restricted to the contract owner via the `onlyOwner` modifier. It takes an `address` `vault` and a `string` `metadata` as input. It first checks if the provided `vault` address is actually whitelisted by checking the `isWhitelistedVault` storage mapping. If it's not whitelisted, it reverts with `NotWhitelistedVault.selector.revertWith()`. If the vault is whitelisted, it emits the `WhitelistedVaultMetadataUpdated` event with the vault address and the new metadata. This function does not modify any storage variables but relies on the state stored in `isWhitelistedVault`."
  },
  "BeraChef_V0.setDefaultRewardAllocation": {
    "type": "external",
    "function_name": "setDefaultRewardAllocation(RewardAllocation calldata ra)",
    "analysis_result": "This function allows the contract owner to set the default reward allocation that will be used for validators who do not have their own valid active allocation. It is restricted to the contract owner via the `onlyOwner` modifier. It takes a `RewardAllocation` struct `ra` as calldata input. It first calls the internal function `_validateWeights` with `ra.weights` to ensure the provided allocation is valid (correct number of weights, total weight sums to 100%, and all included vaults are whitelisted). If validation passes, it emits the `SetDefaultRewardAllocation` event and updates the `defaultRewardAllocation` storage variable with the provided `ra`. It uses the storage variable `defaultRewardAllocation` and calls the internal function `_validateWeights`."
  },
  "BeraChef_V0.queueNewRewardAllocation": {
    "type": "external",
    "function_name": "queueNewRewardAllocation(bytes calldata valPubkey, uint64 startBlock, Weight[] calldata weights)",
    "analysis_result": "This function allows a validator's operator to queue a new reward allocation for that specific validator. It is restricted to the operator of the validator identified by `valPubkey` via the `onlyOperator(valPubkey)` modifier. It takes `bytes calldata valPubkey`, `uint64 startBlock`, and `Weight[] calldata weights` as input. It first checks if the `startBlock` is sufficiently in the future, specifically `startBlock <= block.number + rewardAllocationBlockDelay`. If it's not, it reverts with `InvalidStartBlock.selector.revertWith()`. It then checks if there is already a queued reward allocation for the given `valPubkey` by checking if `queuedRewardAllocations[valPubkey].startBlock` is greater than 0. If a queue already exists, it reverts with `RewardAllocationAlreadyQueued.selector.revertWith()`. It calls the internal function `_validateWeights` with the provided `weights` to ensure they are valid according to the contract rules (number of weights, total weight, whitelisted vaults). If validation passes, it stores the `startBlock` and copies the `weights` into the `queuedRewardAllocations[valPubkey]` storage mapping. Finally, it emits the `QueueRewardAllocation` event. It uses the storage variables `queuedRewardAllocations` and `rewardAllocationBlockDelay`, and calls the internal function `_validateWeights`."
  },
  "BeraChef_V0.activateReadyQueuedRewardAllocation": {
    "type": "external",
    "function_name": "activateReadyQueuedRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This function allows the distributor to activate a queued reward allocation for a validator if its start block has passed. It is restricted to the `distributor` address via the `onlyDistributor` modifier. It takes `bytes calldata valPubkey` as input. It first calls the `isQueuedRewardAllocationReady` public view function (passing `block.number`) to check if the queued allocation for `valPubkey` is ready to be activated. If it is not ready, the function simply returns without doing anything. If it is ready, it retrieves the queued allocation from `queuedRewardAllocations[valPubkey]`, copies it to the `activeRewardAllocations[valPubkey]` storage mapping, emits the `ActivateRewardAllocation` event, and then deletes the entry from the `queuedRewardAllocations` mapping. This moves the allocation from a pending state to an active state. It uses the storage variables `queuedRewardAllocations` and `activeRewardAllocations`, and calls the public view function `isQueuedRewardAllocationReady`."
  },
  "BeraChef_V0.getActiveRewardAllocation": {
    "type": "external",
    "function_name": "getActiveRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This is a public view function that returns the currently effective reward allocation for a given validator public key. It takes `bytes calldata valPubkey` as input and returns a `RewardAllocation` memory struct. It first retrieves the `activeRewardAllocations[valPubkey]` storage entry into a memory variable `ara`. It then checks if `ara.startBlock > 0` (meaning an active allocation exists) and if the weights within `ara` are still valid by calling the internal function `_checkIfStillValid(ara.weights)`. If both conditions are true, it returns `ara`. Otherwise (if no active allocation exists, or the active allocation's weights are no longer valid due to a vault being de-whitelisted), it returns the `defaultRewardAllocation` storage variable. This function determines which allocation applies when rewards are distributed. It uses the storage variables `activeRewardAllocations` and `defaultRewardAllocation`, and calls the internal function `_checkIfStillValid`."
  },
  "BeraChef_V0.getQueuedRewardAllocation": {
    "type": "external",
    "function_name": "getQueuedRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This is a public view function that returns the pending (queued) reward allocation for a given validator public key. It takes `bytes calldata valPubkey` as input and returns a `RewardAllocation` memory struct. It simply returns the value stored in the `queuedRewardAllocations[valPubkey]` storage mapping. If no allocation is queued, it will return a struct with default values (startBlock 0, empty weights array). It uses the storage variable `queuedRewardAllocations`."
  },
  "BeraChef_V0.getSetActiveRewardAllocation": {
    "type": "external",
    "function_name": "getSetActiveRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This is a public view function that returns the *set* active reward allocation for a given validator public key, *without* performing the validity check (`_checkIfStillValid`). This differs from `getActiveRewardAllocation` which falls back to the default if the set active one is invalid. It takes `bytes calldata valPubkey` as input and returns a `RewardAllocation` memory struct. It directly returns the value stored in the `activeRewardAllocations[valPubkey]` storage mapping. It uses the storage variable `activeRewardAllocations`."
  },
  "BeraChef_V0.getDefaultRewardAllocation": {
    "type": "external",
    "function_name": "getDefaultRewardAllocation()",
    "analysis_result": "This is a public view function that returns the current default reward allocation. It takes no input parameters and returns a `RewardAllocation` memory struct. It simply returns the value stored in the `defaultRewardAllocation` storage variable. It uses the storage variable `defaultRewardAllocation`."
  },
  "BeraChef_V0.isQueuedRewardAllocationReady": {
    "type": "public",
    "function_name": "isQueuedRewardAllocationReady(bytes calldata valPubkey, uint256 blockNumber)",
    "analysis_result": "This is a public view function that checks if a queued reward allocation for a given validator pubkey is ready to be activated based on a provided block number. It takes `bytes calldata valPubkey` and `uint256 blockNumber` as input and returns a `bool`. It retrieves the `startBlock` of the queued allocation from `queuedRewardAllocations[valPubkey]`. It returns `true` if the `startBlock` is not 0 (indicating an allocation is queued) and the `startBlock` is less than or equal to the provided `blockNumber`. Otherwise, it returns `false`. It uses the storage variable `queuedRewardAllocations`."
  },
  "BeraChef_V0.isReady": {
    "type": "external",
    "function_name": "isReady()",
    "analysis_result": "This is a public view function that indicates whether the BeraChef contract is ready to function, which is defined as having the default reward allocation set. It takes no input parameters and returns a `bool`. It checks if the length of the `weights` array within the `defaultRewardAllocation` storage variable is greater than 0. If it is, it returns `true`, indicating the contract is ready. Otherwise, it returns `false`. It uses the storage variable `defaultRewardAllocation`."
  },
  "BeraChef_V0._validateWeights": {
    "type": "internal",
    "function_name": "_validateWeights(Weight[] calldata weights)",
    "analysis_result": "This is an internal view function used to validate the structure and content of a `Weight[]` array representing a reward allocation. It takes `Weight[] calldata weights` as input. It first checks if the number of weights (`weights.length`) exceeds the `maxNumWeightsPerRewardAllocation` storage variable. If it does, it reverts with `TooManyWeights.selector.revertWith()`. It then iterates through each `Weight` in the array. Inside the loop, it checks if `weight.percentageNumerator` is 0 and reverts with `ZeroPercentageWeight.selector.revertWith()` if it is. It also checks if the `weight.receiver` address is whitelisted by checking the `isWhitelistedVault` storage mapping. If any receiver is not whitelisted, it reverts with `NotWhitelistedVault.selector.revertWith()`. It accumulates the `percentageNumerator` values into `totalWeight`. After the loop, it checks if `totalWeight` is exactly equal to the `ONE_HUNDRED_PERCENT` constant (1e4). If the total is not 100%, it reverts with `InvalidRewardAllocationWeights.selector.revertWith()`. This function does not modify storage but reads from `maxNumWeightsPerRewardAllocation` and `isWhitelistedVault`."
  },
  "BeraChef_V0._checkIfStillValid": {
    "type": "internal",
    "function_name": "_checkIfStillValid(Weight[] memory weights)",
    "analysis_result": "This is an internal view function used to check if the weights of an *existing* reward allocation are still valid *after* it has been set, primarily used to check if any receivers have been de-whitelisted or if the max number of weights has been reduced. It takes `Weight[] memory weights` as input and returns a `bool`. It first checks if the `length` of the weights array is greater than the current `maxNumWeightsPerRewardAllocation` storage variable. If so, the allocation is no longer valid and it returns `false`. It then iterates through each `Weight` in the array. Inside the loop, it checks if the `weight.receiver` address is still whitelisted using the `isWhitelistedVault` storage mapping. If it finds any receiver that is *not* whitelisted, it immediately returns `false`. If the loop completes without finding any non-whitelisted receivers (and the length check passed), it returns `true`, indicating the allocation is still valid. This function does not modify storage but reads from `maxNumWeightsPerRewardAllocation` and `isWhitelistedVault`."
  },
  "HoneyFactory_V0.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "Initializes the contract. It calls `_disableInitializers()` which is part of the UUPS upgrade pattern, indicating that state initialization will happen in a separate `initialize` function."
  },
  "HoneyFactory_V0.initialize": {
    "type": "external",
    "function_name": "initialize(address _governance, address _honey, address _polFeeCollector, address _feeReceiver, address _priceOracle)",
    "analysis_result": "Initializes the factory contract state. It is protected by the `initializer` modifier (from inherited UUPS upgrade pattern), ensuring it can only be called once. It calls `__VaultAdmin_init` from the base `VaultAdmin_V0` contract to set governance, POL fee collector, and fee receiver addresses. It checks if the provided `_honey` and `_priceOracle` addresses are non-zero, reverting with `ZeroAddress` if not. It sets the `honey` state variable. It initializes `polFeeCollectorFeeRate` to `ONE_HUNDRED_PERCENT_RATE` (100%). It sets default values for `priceFeedMaxDelay` (10 seconds) and `minSharesToRecapitalize`. It sets the `priceOracle` state variable. It initializes `globalCap` to `ONE_HUNDRED_PERCENT_RATE` and sets `liquidationEnabled` to false. Variables modified: `governance`, `polFeeCollector`, `feeReceiver` (via `__VaultAdmin_init`), `honey`, `polFeeCollectorFeeRate`, `priceFeedMaxDelay`, `minSharesToRecapitalize`, `priceOracle`, `globalCap`, `liquidationEnabled`. Calls `__VaultAdmin_init`."
  },
  "HoneyFactory_V0.setMintRate": {
    "type": "external",
    "function_name": "setMintRate(address asset, uint256 mintRate)",
    "analysis_result": "Allows a user with the `MANAGER_ROLE` to set the `mintRates` for a specific `asset`. It checks the caller's role using `_checkRole(MANAGER_ROLE)`. It reverts with `OverOneHundredPercentRate` if `mintRate` is greater than `ONE_HUNDRED_PERCENT_RATE`. It reverts with `UnderNinetyEightPercentRate` if `mintRate` is less than `NINETY_EIGHT_PERCENT_RATE`. It updates the `mintRates` mapping for the given asset. Emits `MintRateSet` event. Variables modified: `mintRates`. Checks role: `MANAGER_ROLE`."
  },
  "HoneyFactory_V0.setRedeemRate": {
    "type": "external",
    "function_name": "setRedeemRate(address asset, uint256 redeemRate)",
    "analysis_result": "Allows a user with the `MANAGER_ROLE` to set the `redeemRates` for a specific `asset`. It checks the caller's role using `_checkRole(MANAGER_ROLE)`. It reverts with `OverOneHundredPercentRate` if `redeemRate` is greater than `ONE_HUNDRED_PERCENT_RATE`. It reverts with `UnderNinetyEightPercentRate` if `redeemRate` is less than `NINETY_EIGHT_PERCENT_RATE`. It updates the `redeemRates` mapping for the given asset. Emits `RedeemRateSet` event. Variables modified: `redeemRates`. Checks role: `MANAGER_ROLE`."
  },
  "HoneyFactory_V0.setForcedBasketMode": {
    "type": "external",
    "function_name": "setForcedBasketMode(bool forced)",
    "analysis_result": "Allows a user with the `MANAGER_ROLE` to force or unforce the basket mode (`forcedBasketMode`). It checks the caller's role using `_checkRole(MANAGER_ROLE)`. It updates the `forcedBasketMode` state variable. Emits `BasketModeForced` event. Variables modified: `forcedBasketMode`. Checks role: `MANAGER_ROLE`."
  },
  "HoneyFactory_V0.setMaxFeedDelay": {
    "type": "external",
    "function_name": "setMaxFeedDelay(uint256 maxTolerance)",
    "analysis_result": "Allows a user with the `MANAGER_ROLE` to set the maximum tolerated delay for price feed updates (`priceFeedMaxDelay`). It checks the caller's role using `_checkRole(MANAGER_ROLE)`. It reverts with `AmountOutOfRange` if `maxTolerance` is greater than `MAX_PRICE_FEED_DELAY_TOLERANCE` (120 seconds). It updates the `priceFeedMaxDelay` state variable. Emits `MaxFeedDelaySet` event. Variables modified: `priceFeedMaxDelay`. Checks role: `MANAGER_ROLE`."
  },
  "HoneyFactory_V0.setDepegOffsets": {
    "type": "external",
    "function_name": "setDepegOffsets(address asset, uint256 lowerOffset, uint256 upperOffset)",
    "analysis_result": "Allows a user with the `MANAGER_ROLE` to set the lower and upper offsets for deeming an asset depegged. It checks the caller's role using `_checkRole(MANAGER_ROLE)`. It calls `_checkRegisteredAsset` to ensure the asset has a registered vault. It reverts with `AmountOutOfRange` if either `lowerOffset` or `upperOffset` is greater than `MAX_PEG_OFFSET` (0.02e18, i.e., 2 cents). It updates the `lowerPegOffsets` and `upperPegOffsets` mappings for the given asset. Emits `DepegOffsetsSet` event. Variables modified: `lowerPegOffsets`, `upperPegOffsets`. Checks role: `MANAGER_ROLE`. Calls `_checkRegisteredAsset`."
  },
  "HoneyFactory_V0.setReferenceCollateral": {
    "type": "external",
    "function_name": "setReferenceCollateral(address asset)",
    "analysis_result": "Allows a user with the `MANAGER_ROLE` to set the `referenceCollateral` asset used for calculating relative caps. It checks the caller's role using `_checkRole(MANAGER_ROLE)`. It calls `_checkRegisteredAsset` to ensure the asset has a registered vault. It stores the old reference collateral address. It updates the `referenceCollateral` state variable. Emits `ReferenceCollateralSet` event with the old and new reference collateral addresses. Variables modified: `referenceCollateral`. Checks role: `MANAGER_ROLE`. Calls `_checkRegisteredAsset`."
  },
  "HoneyFactory_V0.setGlobalCap": {
    "type": "external",
    "function_name": "setGlobalCap(uint256 limit)",
    "analysis_result": "Allows a user with the `MANAGER_ROLE` to set the `globalCap` limit for collateral weights. It checks the caller's role using `_checkRole(MANAGER_ROLE)`. It retrieves current asset weights using `_getWeights(true, false)` (filtering bad collaterals, not paused ones). It finds the maximum weight among the current assets. It reverts with `CapCanCauseDenialOfService` if the proposed `limit` is less than the current maximum asset weight, preventing a potential DoS on redeem. It updates the `globalCap` state variable. Emits `GlobalCapSet` event. Variables modified: `globalCap`. Checks role: `MANAGER_ROLE`. Calls `_getWeights`."
  },
  "HoneyFactory_V0.setRelativeCap": {
    "type": "external",
    "function_name": "setRelativeCap(address asset, uint256 limit)",
    "analysis_result": "Allows a user with the `MANAGER_ROLE` to set the `relativeCap` limit for a specific asset's weight relative to the `referenceCollateral`. It checks the caller's role using `_checkRole(MANAGER_ROLE)`. It updates the `relativeCap` mapping for the given asset. Emits `RelativeCapSet` event. Variables modified: `relativeCap`. Checks role: `MANAGER_ROLE`."
  },
  "HoneyFactory_V0.setPOLFeeCollectorFeeRate": {
    "type": "external",
    "function_name": "setPOLFeeCollectorFeeRate(uint256 _polFeeCollectorFeeRate)",
    "analysis_result": "Allows a user with the `DEFAULT_ADMIN_ROLE` to set the `polFeeCollectorFeeRate`. This rate determines the percentage of fees that goes to the POL fee collector. It checks the caller's role using `_checkRole(DEFAULT_ADMIN_ROLE)`. It reverts with `OverOneHundredPercentRate` if `_polFeeCollectorFeeRate` is greater than `ONE_HUNDRED_PERCENT_RATE`. It updates the `polFeeCollectorFeeRate` state variable. Emits `POLFeeCollectorFeeRateSet` event. Variables modified: `polFeeCollectorFeeRate`. Checks role: `DEFAULT_ADMIN_ROLE`."
  },
  "HoneyFactory_V0.setLiquidationEnabled": {
    "type": "external",
    "function_name": "setLiquidationEnabled(bool enabled)",
    "analysis_result": "Allows a user with the `DEFAULT_ADMIN_ROLE` to enable or disable liquidations. It checks the caller's role using `_checkRole(DEFAULT_ADMIN_ROLE)`. It updates the `liquidationEnabled` state variable. Emits `LiquidationStatusSet` event. Variables modified: `liquidationEnabled`. Checks role: `DEFAULT_ADMIN_ROLE`."
  },
  "HoneyFactory_V0.setLiquidationRate": {
    "type": "external",
    "function_name": "setLiquidationRate(address asset, uint256 extraRate)",
    "analysis_result": "Allows a user with the `DEFAULT_ADMIN_ROLE` to set the `liquidationRates` premium for a specific asset. `extraRate` represents the premium *factor* beyond 1x. It checks the caller's role using `_checkRole(DEFAULT_ADMIN_ROLE)`. It calls `_checkRegisteredAsset` to ensure the asset has a registered vault. It updates the `liquidationRates` mapping for the given asset. Emits `LiquidationRateSet` event. Variables modified: `liquidationRates`. Checks role: `DEFAULT_ADMIN_ROLE`. Calls `_checkRegisteredAsset`."
  },
  "HoneyFactory_V0.setMinSharesToRecapitalize": {
    "type": "external",
    "function_name": "setMinSharesToRecapitalize(uint256 minSharesAmount)",
    "analysis_result": "Allows a user with the `DEFAULT_ADMIN_ROLE` to set the minimum amount of shares required for a recapitalization transaction. It checks the caller's role using `_checkRole(DEFAULT_ADMIN_ROLE)`. It reverts with `AmountOutOfRange` if `minSharesAmount` is less than `DEFAULT_MIN_SHARES_TO_RECAPITALIZE` (1 share, 1e18). It updates the `minSharesToRecapitalize` state variable. Emits `MinSharesToRecapitalizeSet` event. Variables modified: `minSharesToRecapitalize`. Checks role: `DEFAULT_ADMIN_ROLE`."
  },
  "HoneyFactory_V0.setRecapitalizeBalanceThreshold": {
    "type": "external",
    "function_name": "setRecapitalizeBalanceThreshold(address asset, uint256 target)",
    "analysis_result": "Allows a user with the `DEFAULT_ADMIN_ROLE` to set the target balance threshold for when a recapitalization is needed for a specific asset. It checks the caller's role using `_checkRole(DEFAULT_ADMIN_ROLE)`. It updates the `recapitalizeBalanceThreshold` mapping for the given asset. Emits `RecapitalizeBalanceThresholdSet` event. Variables modified: `recapitalizeBalanceThreshold`. Checks role: `DEFAULT_ADMIN_ROLE`."
  },
  "HoneyFactory_V0.setPriceOracle": {
    "type": "external",
    "function_name": "setPriceOracle(address priceOracle_)",
    "analysis_result": "Allows a user with the `DEFAULT_ADMIN_ROLE` to replace the `priceOracle` contract address. It checks the caller's role using `_checkRole(DEFAULT_ADMIN_ROLE)`. It reverts with `ZeroAddress` if `priceOracle_` is the zero address. It updates the `priceOracle` state variable. Emits `PriceOracleSet` event. Variables modified: `priceOracle`. Checks role: `DEFAULT_ADMIN_ROLE`."
  },
  "HoneyFactory_V0.createVault": {
    "type": "external",
    "function_name": "createVault(address asset)",
    "analysis_result": "Creates and registers a new ERC4626 vault for the given `asset`. It first checks if there are any registered assets; if not, it sets this asset as the `referenceCollateral`. It calls the internal `_createVault(asset)` function (inherited from `VaultAdmin_V0`) to actually deploy and register the vault. It then sets the default `relativeCap` (100%), `mintRates` (DEFAULT_MINT_REDEEM_RATE), and `redeemRates` (DEFAULT_MINT_REDEEM_RATE) for the new asset. It checks if the new asset is `isPegged` using the price oracle; if not, it reverts with `NotPegged`. If pegged, it sets the default `lowerPegOffsets` and `upperPegOffsets` to `DEFAULT_PEG_OFFSET`. It returns the address of the newly created vault. Variables modified: `referenceCollateral` (conditionally), `registeredAssets` (via `_createVault`), `vaults` (via `_createVault`), `relativeCap`, `mintRates`, `redeemRates`, `lowerPegOffsets`, `upperPegOffsets`. Calls `_createVault`, `numRegisteredAssets`, `isPegged`."
  },
  "HoneyFactory_V0.mint": {
    "type": "external",
    "function_name": "mint(address asset, uint256 amount, address receiver, bool expectBasketMode)",
    "analysis_result": "Allows a user to mint Honey by depositing an `amount` of a specific `asset`. It is protected by the `whenNotPaused` modifier. It calls `_checkRegisteredAsset` to ensure a vault exists for the asset. It determines the current basket mode status using `isBasketModeEnabled(true)` and checks if it matches the `expectBasketMode` parameter, reverting with `UnexpectedBasketModeStatus` if not. If not in basket mode, it checks if the asset is good collateral (`_checkGoodCollateralAsset`) and `isPegged`, reverting if not. It calls the internal `_mint` function with the specified asset, amount, receiver, and basket mode status. If not in basket mode after minting, it checks the global cap using `_isCappedGlobal(true, asset)`, reverting with `ExceedGlobalCap` if the mint caused the cap to be exceeded. If in basket mode, it retrieves asset weights using `_getWeights(false, true)`, determines the reference amount based on the provided asset and amount, calculates the amount for *all* registered assets based on weights, and calls `_mint` for each asset, summing up the minted Honey. It returns the total amount of Honey minted. Variables modified: vault balances, Honey token balance, fee balances (via internal calls). Checks paused state. Calls `_checkRegisteredAsset`, `isBasketModeEnabled`, `_checkGoodCollateralAsset` (conditionally), `isPegged` (conditionally), `_mint`, `_isCappedGlobal` (conditionally), `_getWeights` (conditionally), `_lookupRegistrationIndex` (conditionally), external `ERC20.decimals`, internal `Utils.changeDecimals` (conditionally), external `vaults[].convertToAssets` (conditionally)."
  },
  "HoneyFactory_V0.redeem": {
    "type": "external",
    "function_name": "redeem(address asset, uint256 honeyAmount, address receiver, bool expectBasketMode)",
    "analysis_result": "Allows a user to redeem `honeyAmount` of Honey for assets. It is protected by the `whenNotPaused` modifier. It calls `_checkRegisteredAsset` to ensure a vault exists for the specified asset. It determines the current basket mode status using `isBasketModeEnabled(false)` and checks if it matches the `expectBasketMode` parameter, reverting with `UnexpectedBasketModeStatus` if not. If not in basket mode, it calls the internal `_redeem` function for the specified asset, amount, and receiver. It then checks if the redeemed asset is the `referenceCollateral`; if so, it iterates through *all* registered assets and checks their relative caps using `_isCappedRelative`, reverting with `ExceedRelativeCap` if any asset is now over its relative cap. It also checks the global cap using `_isCappedGlobal(false, asset)`, reverting with `ExceedGlobalCap` if it's exceeded. It returns an array containing the redeemed amount (only for the specified asset in non-basket mode, or for all assets in basket mode). If in basket mode, it retrieves asset weights using `_getWeights(false, true)`, calculates the proportional `honeyAmount` for each asset based on weights, and calls `_redeem` for each asset, storing the redeemed amounts. Variables modified: Honey token balance, vault balances, fee balances (via internal calls). Checks paused state. Calls `_checkRegisteredAsset`, `isBasketModeEnabled`, `_redeem`, `_lookupRegistrationIndex`, `_isCappedRelative` (conditionally), `_isCappedGlobal` (conditionally), `_getWeights` (conditionally)."
  },
  "HoneyFactory_V0.liquidate": {
    "type": "external",
    "function_name": "liquidate(address badCollateral, address goodCollateral, uint256 goodAmount)",
    "analysis_result": "Allows a user to liquidate `badCollateral` by providing `goodCollateral`. It is protected by the `whenNotPaused` modifier. It calls `_checkRegisteredAsset` for both collateral types. It checks if `liquidationEnabled` is true, reverting with `LiquidationDisabled` if not. It checks if `badCollateral` is marked as bad using `isBadCollateralAsset`, reverting if not. It checks if `badCollateral` is the `referenceCollateral`, reverting with `LiquidationWithReferenceCollateral` as this could cause issues with relative caps. It calls `_approveAndDeposit` to transfer and deposit `goodAmount` of `goodCollateral` into its vault, getting the `goodShares`. It retrieves prices for both collaterals using `_getPrice`. It calculates the target `badAmount` based on shares, prices, and the `liquidationRates` premium. It gets the factory's shares of `badCollateral` excluding fees using `_getSharesWithoutFees`. If the calculated `badAmount` exceeds the available bad shares, it recalculates the `goodSharesAdjusted` that should be redeemed to match the available bad shares, redeems the excess good shares to the sender using `_redeemShares`, and sets `badAmount` to the total available bad shares. It checks the relative cap for `goodCollateral` using `_isCappedRelative` and the global cap for `badCollateral` using `_isCappedGlobal(false, badCollateral)`, reverting if exceeded. It calls `_redeemShares` to redeem the calculated `badAmount` of `badCollateral` shares, getting the actual redeemed amount. It reverts with `ZeroAmount` if the actual redeemed amount is zero. It calls `_checkInvariants` for both collateral types. Emits `Liquidated` event. Returns the actual `badAmount` redeemed. Variables modified: vault balances for both collaterals, fee balances (via internal calls). Checks paused state. Calls `_checkRegisteredAsset`, `isBadCollateralAsset`, `_approveAndDeposit`, `_getPrice`, `_getSharesWithoutFees`, `_isCappedRelative`, `_isCappedGlobal`, `_redeemShares`, `_checkInvariants`."
  },
  "HoneyFactory_V0.recapitalize": {
    "type": "external",
    "function_name": "recapitalize(address asset, uint256 amount)",
    "analysis_result": "Allows a user to deposit `amount` of an `asset` into its vault to increase the balance, typically when it's below the target threshold. It is protected by the `whenNotPaused` modifier. It calls `_checkRegisteredAsset` and `_checkGoodCollateralAsset`. It reads the `recapitalizeBalanceThreshold` for the asset. It calculates the current balance in the vault (excluding fees) and checks if it's already greater than or equal to the target, reverting with `RecapitalizeNotNeeded` if so. It checks if the asset `isPegged`, reverting with `NotPegged` if not. If the current balance plus the provided `amount` exceeds the target, it reduces `amount` to only reach the target. It converts the final `amount` to shares to check against the minimum requirement. It checks if the shares are less than `minSharesToRecapitalize`, reverting with `InsufficientRecapitalizeAmount` if so. It calls `_approveAndDeposit` to transfer and deposit the final `amount`. It checks the relative cap using `_isCappedRelative` and the global cap using `_isCappedGlobal(true, asset)`, reverting if exceeded. It calls `_checkInvariants` for the asset. Emits `Recapitalized` event. Variables modified: `recapitalizeBalanceThreshold`, vault balance (via internal calls). Checks paused state. Calls `_checkRegisteredAsset`, `_checkGoodCollateralAsset`, `vaults[].convertToAssets`, `collectedAssetFees`, `vaults[].totalAssets`, `isPegged`, `vaults[].convertToShares`, `_approveAndDeposit`, `_isCappedRelative`, `_isCappedGlobal`, `_checkInvariants`."
  },
  "HoneyFactory_V0.isBasketModeEnabled": {
    "type": "public",
    "function_name": "isBasketModeEnabled(bool isMint)",
    "analysis_result": "Determines if basket mode is enabled for minting or redeeming. Reads `forcedBasketMode`. If true, always returns true. Otherwise, it iterates through all `registeredAssets`. For mint (`isMint` is true), basket mode is disabled if any asset is both `isPegged` and not a `isBadCollateralAsset`. If no such asset is found, basket mode is enabled. For redeem (`isMint` is false), basket mode is enabled if at least one asset is *not* `isPegged` AND has shares held by the factory excluding fees (`_getSharesWithoutFees > 0`). If no such asset is found, basket mode is disabled. Returns the basket mode status. Variables read: `forcedBasketMode`, `registeredAssets`, `isBadCollateralAsset`. Calls `isPegged`, `_getSharesWithoutFees` (conditionally)."
  },
  "HoneyFactory_V0.getWeights": {
    "type": "external",
    "function_name": "getWeights()",
    "analysis_result": "Retrieves the weights of all `registeredAssets`, excluding paused assets, based on the factory's share balance (excluding fees). Calls the internal `_getWeights(false, true)` (filtering bad collaterals: false, filtering paused collaterals: true). Returns an array of weights. Calls `_getWeights`."
  },
  "HoneyFactory_V0.isPegged": {
    "type": "public",
    "function_name": "isPegged(address asset)",
    "analysis_result": "Checks if an `asset` is considered pegged to USD. It calls `priceOracle.priceAvailable(asset)` to check if the oracle has data. If not, returns false. It then calls `priceOracle.getPriceUnsafe(asset)` to get the price data. It checks if the `publishTime` is older than `block.timestamp - priceFeedMaxDelay`, returning false if stale. Finally, it checks if the price `data.price` is within the range `[1e18 - lowerPegOffsets[asset], 1e18 + upperPegOffsets[asset]]`, returning true if within the range (pegged) and false otherwise (depegged). Variables read: `priceFeedMaxDelay`, `lowerPegOffsets`, `upperPegOffsets`. Calls external `priceOracle.priceAvailable`, `priceOracle.getPriceUnsafe`."
  },
  "HoneyFactory_V0._mint": {
    "type": "internal",
    "function_name": "_mint(address asset, uint256 amount, address receiver, bool basketMode)",
    "analysis_result": "Internal function to perform the core Honey minting logic. It deposits `amount` of `asset` from `msg.sender` into the asset's vault by calling `_approveAndDeposit`, getting the corresponding `shares`. It calculates the amount of `honeyToMint` and fees based on the `mintRates` and `polFeeCollectorFeeRate` using `_getHoneyMintedFromShares`. It calls `_handleFees` to distribute the calculated fees (redeeming POL fees immediately, holding fee receiver shares). If `basketMode` is false, it checks the relative cap using `_isCappedRelative`, reverting with `ExceedRelativeCap` if exceeded. It mints `honeyToMint` to the `receiver` by calling `honey.mint`. It calls `_checkInvariants` for the asset. Emits `HoneyMinted`. Returns the amount of Honey minted. Variables modified: vault balance (via `_approveAndDeposit`), Honey token balance (via `honey.mint`), fee balances (via `_handleFees`). Calls `_approveAndDeposit`, `_getHoneyMintedFromShares`, `_handleFees`, `_isCappedRelative` (conditionally), `honey.mint`, `_checkInvariants`."
  },
  "HoneyFactory_V0._redeem": {
    "type": "internal",
    "function_name": "_redeem(address asset, uint256 honeyAmount, address receiver)",
    "analysis_result": "Internal function to perform the core Honey redeeming logic. It calculates the `sharesForRedeem` and fees based on `honeyAmount`, `redeemRates`, and `polFeeCollectorFeeRate` using `_getSharesRedeemedFromHoney`. It burns `honeyAmount` from `msg.sender` by calling `honey.burn`. It calls `_handleFees` to distribute the calculated fees (redeeming POL fees immediately, holding fee receiver shares). It redeems `sharesForRedeem` from the asset's vault to the `receiver` using `_redeemShares`, getting the actual `redeemedAssets` amount. It calls `_checkInvariants` for the asset. Emits `HoneyRedeemed`. Returns the amount of assets redeemed. Variables modified: Honey token balance (via `honey.burn`), vault balance (via `_redeemShares`), fee balances (via `_handleFees`). Calls `_getSharesRedeemedFromHoney`, `honey.burn`, `_handleFees`, `_redeemShares`, `_checkInvariants`."
  },
  "HoneyFactory_V0._getHoneyMintedFromShares": {
    "type": "internal view",
    "function_name": "_getHoneyMintedFromShares(address asset, uint256 shares)",
    "analysis_result": "Calculates the amount of Honey to mint and the fee distribution in shares based on the provided `shares`, `mintRates`, and `polFeeCollectorFeeRate`. Reads `mintRates` and `polFeeCollectorFeeRate`. Returns the amount of Honey, fee receiver shares, and POL fee collector shares. Variables read: `mintRates`, `polFeeCollectorFeeRate`."
  },
  "HoneyFactory_V0._getSharesRedeemedFromHoney": {
    "type": "internal view",
    "function_name": "_getSharesRedeemedFromHoney(address asset, uint256 honeyAmount)",
    "analysis_result": "Calculates the shares to redeem and the fee distribution in shares based on the provided `honeyAmount`, `redeemRates`, and `polFeeCollectorFeeRate`. Reads `redeemRates` and `polFeeCollectorFeeRate`. Returns the shares amount, fee receiver shares, and POL fee collector shares. Variables read: `redeemRates`, `polFeeCollectorFeeRate`."
  },
  "HoneyFactory_V0._getWeights": {
    "type": "internal view",
    "function_name": "_getWeights(bool filterBadCollaterals, bool filterPausedCollateral)",
    "analysis_result": "Calculates the normalized weights of registered assets based on the factory's share balance (excluding fees). It iterates through `registeredAssets`. If `filterBadCollaterals` is true, it skips assets marked as bad (`isBadCollateralAsset`). If `filterPausedCollateral` is true, it skips assets whose vault is paused (`vaults[asset].paused()`). For included assets, it gets the factory's balance excluding collected fees using `_getSharesWithoutFees` as the weight. It calculates the total sum of weights. If the sum is zero, it returns a weights array of zeros. Otherwise, it normalizes each weight by dividing by the total sum (scaled by 1e18). Reads `registeredAssets`, `isBadCollateralAsset`, `vaults`. Calls `_getSharesWithoutFees`, external `vaults[].paused()`."
  },
  "HoneyFactory_V0._isCappedRelative": {
    "type": "internal view",
    "function_name": "_isCappedRelative(address asset)",
    "analysis_result": "Checks if the current weight of an `asset` relative to the `referenceCollateral` exceeds its `relativeCap`. If the asset is the `referenceCollateral`, it always returns true. It gets the factory's shares balance (excluding fees) for both the asset and the reference collateral using `_getSharesWithoutFees`. If the reference balance is zero, it returns true only if the asset balance is also zero. Otherwise, it calculates the weight of the asset relative to the reference collateral. It returns true if the weight is less than or equal to the asset's `relativeCap`, false otherwise. Variables read: `referenceCollateral`, `relativeCap`. Calls `_getSharesWithoutFees`."
  },
  "HoneyFactory_V0._isCappedGlobal": {
    "type": "internal view",
    "function_name": "_isCappedGlobal(bool isMint, address collateralAsset)",
    "analysis_result": "Checks if any asset's weight (optionally including the target asset for mints) exceeds the `globalCap`. It gets asset weights using `_getWeights(true, false)` (filtering bad collaterals, not paused). It iterates through the weights. If `isMint` is true, it only checks the `collateralAsset`. If `isMint` is false (redeem), it checks *all* assets *except* the `collateralAsset` (since reducing the asset being redeemed cannot worsen the global cap). It returns false as soon as it finds an asset whose weight is greater than `globalCap`. If it iterates through all relevant assets without finding one exceeding the cap, it returns true. Variables read: `globalCap`. Calls `_getWeights`, `registeredAssets`, `_lookupRegistrationIndex`."
  },
  "HoneyFactory_V0._getPrice": {
    "type": "internal view",
    "function_name": "_getPrice(address asset)",
    "analysis_result": "Retrieves the price of an `asset` from the `priceOracle`, ensuring the price data is not older than `priceFeedMaxDelay`. It calls `priceOracle.getPriceNoOlderThan`. Returns the price. Variables read: `priceOracle`, `priceFeedMaxDelay`. Calls external `priceOracle.getPriceNoOlderThan`."
  },
  "HoneyFactory_V0._getSharesWithoutFees": {
    "type": "internal view",
    "function_name": "_getSharesWithoutFees(address asset)",
    "analysis_result": "Calculates the factory's share balance in an asset's vault, excluding the collected fees (`collectedAssetFees`). It calls `vaults[asset].balanceOf(address(this))` to get the total shares held by the factory and subtracts `collectedAssetFees[asset]`. Returns the calculated balance. Variables read: `vaults`, `collectedAssetFees`. Calls external `vaults[].balanceOf`."
  },
  "HoneyFactory_V0._approveAndDeposit": {
    "type": "internal",
    "function_name": "_approveAndDeposit(address asset, uint256 amount)",
    "analysis_result": "Handles the transfer and deposit of an `amount` of an `asset` into its corresponding vault. It first transfers the asset from `msg.sender` to the factory using `SafeTransferLib.safeTransferFrom`. It then approves the asset's vault to spend the transferred amount from the factory's balance using `SafeTransferLib.safeApprove`. Finally, it calls `vaults[asset].deposit` to deposit the `amount` into the vault, getting the resulting `shares`. Returns the number of shares minted by the vault. Variables modified: `ERC20(asset)` balance, vault `asset` balance, vault shares balance (via external calls). Calls external `SafeTransferLib.safeTransferFrom`, `SafeTransferLib.safeApprove`, `vaults[].deposit`."
  },
  "HoneyFactory_V0._redeemShares": {
    "type": "internal",
    "function_name": "_redeemShares(address asset, uint256 shares, address receiver)",
    "analysis_result": "Handles the redemption of `shares` from an asset's vault and transfers the resulting assets to a `receiver`. It calls `vaults[asset].redeem` to perform the redemption. Returns the amount of assets redeemed. Variables modified: vault shares balance, vault `asset` balance, `ERC20(asset)` balance (via external call). Calls external `vaults[].redeem`."
  },
  "HoneyFactory_V0._handleFees": {
    "type": "internal",
    "function_name": "_handleFees(address asset, uint256 polFeeCollectorFeeShares, uint256 feeReceiverFeeShares)",
    "analysis_result": "Distributes collected fee shares. If `polFeeCollectorFeeShares` is greater than 0, it immediately redeems those shares from the asset's vault and transfers the assets to the `polFeeCollector` address using `_redeemShares`. If `feeReceiverFeeShares` is greater than 0, it adds those shares to the `collectedFees` mapping for the `feeReceiver` and the `collectedAssetFees` mapping for the `asset`. Variables modified: `collectedFees`, `collectedAssetFees`. Calls `_redeemShares` (conditionally)."
  },
  "HoneyFactory_V0._checkInvariants": {
    "type": "internal view",
    "function_name": "_checkInvariants(address asset)",
    "analysis_result": "Checks two invariants for a given `asset`'s vault to ensure solvency. First, it checks if the total assets held by the vault (`ERC20(asset).balanceOf(address(vault))`) are greater than or equal to the value of the total shares converted to assets (`vault.convertToAssets(vault.totalSupply())`), reverting with `InsufficientAssets` if not. Second, it checks if the factory's shares balance in the vault (`vault.balanceOf(address(this))`) is greater than or equal to the `collectedAssetFees` for that asset, reverting with `InsufficientAssets` if not (as the factory should hold at least the fee shares). Variables read: `vaults`, `collectedAssetFees`. Calls external `vaults[].totalSupply`, `ERC20(asset).balanceOf`, `vaults[].convertToAssets`, `vaults[].balanceOf`."
  },
  "RewardVault_V0.onlyDistributor": {
    "type": "modifier",
    "function_name": "onlyDistributor()",
    "analysis_result": "Purpose: Restricts access to the function to only the address stored in the `distributor` state variable. Variables Used: `distributor` (read). Internal/External Calls: Implicitly `NotDistributor.selector.revertWith()`. Logic: Checks if `msg.sender` is equal to the `distributor` address. If not, it reverts with a custom error `NotDistributor`. Events: None. Modifiers Applied: N/A. Error Conditions: Reverts with `NotDistributor` if `msg.sender` is not the `distributor` address."
  },
  "RewardVault_V0.onlyOperatorOrUser": {
    "type": "modifier",
    "function_name": "onlyOperatorOrUser(address account)",
    "analysis_result": "Purpose: Restricts access to the function to either the specified `account` or its designated operator (`_operators[account]`). Variables Used: `_operators` (read). Internal/External Calls: Implicitly `NotOperator.selector.revertWith()`. Logic: Takes an `account` address as an argument. Checks if `msg.sender` is equal to the `account`. If not, it checks if `msg.sender` is equal to the operator stored for `account` in the `_operators` mapping. If neither is true, it reverts with a custom error `NotOperator`. Events: None. Modifiers Applied: N/A. Error Conditions: Reverts with `NotOperator` if `msg.sender` is neither the `account` nor its registered operator."
  },
  "RewardVault_V0.checkSelfStakedBalance": {
    "type": "modifier",
    "function_name": "checkSelfStakedBalance(address account, uint256 amount)",
    "analysis_result": "Purpose: Ensures that an account has a sufficient amount of *self-staked* balance before proceeding with an operation (like withdrawal). Variables Used: N/A (logic delegated to internal function). Internal/External Calls: Calls the internal function `_checkSelfStakedBalance(account, amount)`. Logic: Takes an `account` and an `amount` as arguments. Calls the internal function `_checkSelfStakedBalance` to perform the validation. Events: None. Modifiers Applied: N/A. Error Conditions: Reverts if the called internal function `_checkSelfStakedBalance` reverts (due to insufficient self-staked amount)."
  },
  "RewardVault_V0.onlyWhitelistedToken": {
    "type": "modifier",
    "function_name": "onlyWhitelistedToken(address token)",
    "analysis_result": "Purpose: Restricts access to the function to operations involving only whitelisted incentive tokens. Variables Used: `incentives` (read). Internal/External Calls: Implicitly `TokenNotWhitelisted.selector.revertWith()`. Logic: Takes a `token` address as an argument. Checks if the `minIncentiveRate` for this `token` in the `incentives` mapping is non-zero. A non-zero `minIncentiveRate` is used as the indicator that the token is whitelisted. If the `minIncentiveRate` is 0, it reverts with a custom error `TokenNotWhitelisted`. Events: None. Modifiers Applied: N/A. Error Conditions: Reverts with `TokenNotWhitelisted` if the provided `token` address is not found in the `incentives` mapping with a non-zero `minIncentiveRate`."
  },
  "RewardVault_V0.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "Purpose: Standard constructor for upgradeable contracts using OpenZeppelin's UUPS pattern. Prevents execution of the `initialize` function during initial deployment by disabling initializers. Variables Used: None directly; affects internal state for upgradeability. Internal/External Calls: Calls `_disableInitializers()` (internal from OpenZeppelin Upgrades). Logic: Executes `_disableInitializers()`. Events: None. Modifiers Applied: `custom:oz-upgrades-unsafe-allow constructor`. Error Conditions: N/A."
  },
  "RewardVault_V0.initialize": {
    "type": "external",
    "function_name": "initialize(address _beaconDepositContract, address _bgt, address _distributor, address _stakingToken)",
    "analysis_result": "Purpose: Initializes the contract state. Called once after deployment for upgradeable contracts. Sets up base contract initializers and initial state variables. Variables Used: `factoryOwner` (written, inherited), `_paused` (written, inherited), `_status` (written, inherited), `stakeToken` (written, inherited), `rewardToken` (written, inherited), `rewardsDuration` (written, inherited), `maxIncentiveTokensCount` (written), `distributor` (written), `beaconDepositContract` (written). Internal/External Calls: Calls `__FactoryOwnable_init`, `__Pausable_init`, `__ReentrancyGuard_init`, `__StakingRewards_init`. External call to `IBeaconDeposit`. Logic: Initializes inherited base contracts. Sets `maxIncentiveTokensCount` to 2. Sets the `distributor` and `beaconDepositContract` addresses. Events: Emits `DistributorSet`, `MaxIncentiveTokensCountUpdated`. Modifiers Applied: `initializer`. Error Conditions: Reverts if called more than once. Reverts if `_distributor` is zero address (checked in `setDistributor` but noted as slither disable here)."
  },
  "RewardVault_V0.setDistributor": {
    "type": "external",
    "function_name": "setDistributor(address _rewardDistribution)",
    "analysis_result": "Purpose: Allows the `factoryOwner` to change the address of the distributor contract. Variables Used: `distributor` (written). Internal/External Calls: Implicitly `ZeroAddress.selector.revertWith()`. Logic: Checks if the provided `_rewardDistribution` address is the zero address. If valid, updates the `distributor` state variable. Events: Emits `DistributorSet`. Modifiers Applied: `onlyFactoryOwner`. Error Conditions: Reverts if called by an address that is not the `factoryOwner`. Reverts with `ZeroAddress` if `_rewardDistribution` is the zero address."
  },
  "RewardVault_V0.notifyRewardAmount": {
    "type": "external",
    "function_name": "notifyRewardAmount(bytes calldata pubkey, uint256 reward)",
    "analysis_result": "Purpose: Called by the `distributor` to notify the contract about new BGT rewards and trigger the processing of incentive tokens for the validator associated with the provided pubkey. Variables Used: Inherited `undistributedRewards`, etc. Internal/External Calls: Calls `_notifyRewardAmount(reward)` (internal, inherited from StakingRewards), `_processIncentives(pubkey, reward)` (internal). Logic: Calls the base contract's `_notifyRewardAmount` to handle BGT reward accounting. Then calls `_processIncentives` to attempt distributing whitelisted incentive tokens. Events: May emit events from `_notifyRewardAmount` (e.g., `RewardAdded`). Emits events from `_processIncentives` (`IncentivesProcessed`, `IncentivesProcessFailed`). Modifiers Applied: `onlyDistributor`. Error Conditions: Reverts if called by an address that is not the `distributor`. Reverts if `_notifyRewardAmount` or `_processIncentives` revert."
  },
  "RewardVault_V0.recoverERC20": {
    "type": "external",
    "function_name": "recoverERC20(address tokenAddress, uint256 tokenAmount)",
    "analysis_result": "Purpose: Allows the `factoryOwner` to retrieve ERC20 tokens mistakenly sent to the contract address, with restrictions to prevent recovering stake or incentive tokens. Variables Used: `stakeToken` (read, inherited), `incentives` (read). Internal/External Calls: External call to `IERC20(tokenAddress).safeTransfer(msg.sender, tokenAmount)` using SafeERC20. Implicitly reverts with custom errors (`CannotRecoverStakingToken`, `CannotRecoverIncentiveToken`). Logic: Checks if `tokenAddress` is the staking token or a whitelisted incentive token (by checking if `incentives[tokenAddress].minIncentiveRate` is non-zero). If it is a restricted token, it reverts. Otherwise, it safely transfers the specified `tokenAmount` to the `msg.sender`. Events: Emits `Recovered`. Modifiers Applied: `onlyFactoryOwner`. Error Conditions: Reverts if called by an address that is not the `factoryOwner`. Reverts with `CannotRecoverStakingToken` if `tokenAddress` is the `stakeToken`. Reverts with `CannotRecoverIncentiveToken` if `tokenAddress` is a whitelisted incentive token. May revert if `safeTransfer` fails."
  },
  "RewardVault_V0.setRewardsDuration": {
    "type": "external",
    "function_name": "setRewardsDuration(uint256 _rewardsDuration)",
    "analysis_result": "Purpose: Allows the `factoryOwner` to change the duration over which the BGT rewards are distributed. Variables Used: Inherited `rewardsDuration` (written) and related reward calculation state. Internal/External Calls: Calls `_setRewardsDuration(_rewardsDuration)` (internal, inherited from StakingRewards). Logic: Calls the base contract's `_setRewardsDuration` function to update the reward distribution duration. Events: May emit events from `_setRewardsDuration` (e.g., `RewardsDurationUpdated`). Modifiers Applied: `onlyFactoryOwner`. Error Conditions: Reverts if called by an address that is not the `factoryOwner`. Reverts if `_setRewardsDuration` reverts (e.g., if called before the current reward period ends)."
  },
  "RewardVault_V0.whitelistIncentiveToken": {
    "type": "external",
    "function_name": "whitelistIncentiveToken(address token, uint256 minIncentiveRate, address manager)",
    "analysis_result": "Purpose: Allows the `factoryOwner` to add a new token to the list of whitelisted incentive tokens, defining its minimum incentive rate and the manager address responsible for adding incentives. Variables Used: `incentives` (written), `whitelistedTokens` (written), `maxIncentiveTokensCount` (read), `MAX_INCENTIVE_RATE` (read). Internal/External Calls: Implicitly reverts with custom errors (`MinIncentiveRateIsZero`, `IncentiveRateTooHigh`, `ZeroAddress`, `TokenAlreadyWhitelistedOrLimitReached`). Logic: Validates `minIncentiveRate`, `token`, and `manager` addresses. Checks if the maximum number of whitelisted tokens has been reached or if the token is already whitelisted. If valid and not already whitelisted or at limit, adds the token to the `whitelistedTokens` array and initializes its entry in the `incentives` mapping, setting `minIncentiveRate`, `incentiveRate`, and `manager`. Events: Emits `IncentiveTokenWhitelisted`. Modifiers Applied: `onlyFactoryOwner`. Error Conditions: Reverts if called by an address that is not the `factoryOwner`. Reverts with `MinIncentiveRateIsZero` if `minIncentiveRate` is 0. Reverts with `IncentiveRateTooHigh` if `minIncentiveRate` exceeds `MAX_INCENTIVE_RATE`. Reverts with `ZeroAddress` if `token` or `manager` is the zero address. Reverts with `TokenAlreadyWhitelistedOrLimitReached` if `whitelistedTokens.length` equals `maxIncentiveTokensCount` or if `token` is already whitelisted."
  },
  "RewardVault_V0.removeIncentiveToken": {
    "type": "external",
    "function_name": "removeIncentiveToken(address token)",
    "analysis_result": "Purpose: Allows the `factoryVaultManager` to remove a token from the list of whitelisted incentive tokens. Variables Used: `incentives` (written), `whitelistedTokens` (written). Internal/External Calls: Calls `_deleteWhitelistedTokenFromList(token)` (internal). Implicitly reverts with custom error (`TokenNotWhitelisted`). Logic: Uses the `onlyWhitelistedToken` modifier to ensure the token is currently whitelisted. Deletes the incentive data for the `token` from the `incentives` mapping. Calls the internal helper `_deleteWhitelistedTokenFromList` to remove the token address from the `whitelistedTokens` array. Events: Emits `IncentiveTokenRemoved`. Modifiers Applied: `onlyFactoryVaultManager`, `onlyWhitelistedToken(token)`. Error Conditions: Reverts if called by an address that is not the `factoryVaultManager`. Reverts with `TokenNotWhitelisted` if the token is not whitelisted."
  },
  "RewardVault_V0.updateIncentiveManager": {
    "type": "external",
    "function_name": "updateIncentiveManager(address token, address newManager)",
    "analysis_result": "Purpose: Allows the `factoryOwner` to change the manager address for an existing whitelisted incentive token. Variables Used: `incentives` (written). Internal/External Calls: Implicitly reverts with custom errors (`ZeroAddress`, `TokenNotWhitelisted`). Logic: Uses the `onlyWhitelistedToken` modifier to ensure the token is whitelisted. Checks if the `newManager` address is the zero address. If valid, updates the `manager` field in the `Incentive` struct for the specified `token`. Events: Emits `IncentiveManagerChanged`. Modifiers Applied: `onlyFactoryOwner`, `onlyWhitelistedToken(token)`. Error Conditions: Reverts if called by an address that is not the `factoryOwner`. Reverts with `TokenNotWhitelisted` if the token is not whitelisted. Reverts with `ZeroAddress` if `newManager` is the zero address."
  },
  "RewardVault_V0.setMaxIncentiveTokensCount": {
    "type": "external",
    "function_name": "setMaxIncentiveTokensCount(uint8 _maxIncentiveTokensCount)",
    "analysis_result": "Purpose: Allows the `factoryOwner` to change the maximum number of incentive tokens that can be whitelisted. Variables Used: `maxIncentiveTokensCount` (written), `whitelistedTokens` (read). Internal/External Calls: Implicitly reverts with custom error (`InvalidMaxIncentiveTokensCount`). Logic: Checks if the proposed `_maxIncentiveTokensCount` is less than the current number of whitelisted tokens (`whitelistedTokens.length`). If it is, it reverts with `InvalidMaxIncentiveTokensCount`. Otherwise, updates the `maxIncentiveTokensCount` state variable. Events: Emits `MaxIncentiveTokensCountUpdated`. Modifiers Applied: `onlyFactoryOwner`. Error Conditions: Reverts if called by an address that is not the `factoryOwner`. Reverts with `InvalidMaxIncentiveTokensCount` if `_maxIncentiveTokensCount` is less than the current count of whitelisted tokens."
  },
  "RewardVault_V0.pause": {
    "type": "external",
    "function_name": "pause()",
    "analysis_result": "Purpose: Allows the `factoryVaultPauser` to pause the contract, preventing execution of functions marked with `whenNotPaused`. Variables Used: `_paused` (written, inherited). Internal/External Calls: Calls `_pause()` (internal, inherited from PausableUpgradeable). Logic: Calls the base contract's `_pause()` function to set the paused state. Events: Emits `Paused` (inherited). Modifiers Applied: `onlyFactoryVaultPauser`. Error Conditions: Reverts if called by an address that is not the `factoryVaultPauser`. Reverts if the contract is already paused."
  },
  "RewardVault_V0.unpause": {
    "type": "external",
    "function_name": "unpause()",
    "analysis_result": "Purpose: Allows the `factoryVaultManager` to unpause the contract, allowing execution of functions marked with `whenNotPaused`. Variables Used: `_paused` (written, inherited). Internal/External Calls: Calls `_unpause()` (internal, inherited from PausableUpgradeable). Logic: Calls the base contract's `_unpause()` function to unset the paused state. Events: Emits `Unpaused` (inherited). Modifiers Applied: `onlyFactoryVaultManager`. Error Conditions: Reverts if called by an address that is not the `factoryVaultManager`. Reverts if the contract is already unpaused."
  },
  "RewardVault_V0.operator": {
    "type": "external view",
    "function_name": "operator(address account)",
    "analysis_result": "Purpose: Returns the operator address set for a given account. Variables Used: `_operators` (read). Internal/External Calls: None. Logic: Looks up the `account` in the `_operators` mapping and returns the associated operator address. Returns the zero address if no operator is set. Events: None. Modifiers Applied: None. Error Conditions: None."
  },
  "RewardVault_V0.getWhitelistedTokensCount": {
    "type": "external view",
    "function_name": "getWhitelistedTokensCount()",
    "analysis_result": "Purpose: Returns the current number of whitelisted incentive tokens. Variables Used: `whitelistedTokens` (read). Internal/External Calls: None. Logic: Returns the length of the `whitelistedTokens` array. Events: None. Modifiers Applied: None. Error Conditions: None."
  },
  "RewardVault_V0.getWhitelistedTokens": {
    "type": "public view",
    "function_name": "getWhitelistedTokens()",
    "analysis_result": "Purpose: Returns the list of addresses of all currently whitelisted incentive tokens. Variables Used: `whitelistedTokens` (read). Internal/External Calls: None. Logic: Returns a memory copy of the `whitelistedTokens` array. Events: None. Modifiers Applied: None. Error Conditions: None."
  },
  "RewardVault_V0.getTotalDelegateStaked": {
    "type": "external view",
    "function_name": "getTotalDelegateStaked(address account)",
    "analysis_result": "Purpose: Returns the total amount of `stakeToken` staked on behalf of a specific `account` by any delegate. Variables Used: `_delegateStake` (read). Internal/External Calls: None. Logic: Accesses the `_delegateStake` mapping for the given `account` and returns the value of its `delegateTotalStaked` field. Events: None. Modifiers Applied: None. Error Conditions: None."
  },
  "RewardVault_V0.getDelegateStake": {
    "type": "external view",
    "function_name": "getDelegateStake(address account, address delegate)",
    "analysis_result": "Purpose: Returns the amount of `stakeToken` staked on behalf of a specific `account` by a specific `delegate`. Variables Used: `_delegateStake` (read). Internal/External Calls: None. Logic: Accesses the `_delegateStake` mapping for the given `account` and then the `stakedByDelegate` mapping within it for the given `delegate`, returning the stored amount. Returns 0 if the delegate has not staked for the account. Events: None. Modifiers Applied: None. Error Conditions: None."
  },
  "RewardVault_V0.stake": {
    "type": "external",
    "function_name": "stake(uint256 amount)",
    "analysis_result": "Purpose: Allows the `msg.sender` to stake their own `stakeToken` in the vault. Variables Used: Inherited state (`totalSupply`, `_accountInfo`, etc.) and potentially `stakeToken`. Internal/External Calls: Calls `_stake(msg.sender, amount)` (internal, inherited from StakingRewards). May involve external token transfer via `stakeToken.transferFrom`. Logic: Calls the internal `_stake` function inherited from `StakingRewards` with `msg.sender` as the account. Handles core staking logic, including updating balances and total supply. Events: May emit events from `_stake` (e.g., `Staked`, `RewardPaid`). Modifiers Applied: `nonReentrant`, `whenNotPaused`. Error Conditions: Reverts if the contract is paused. Reverts if reentrancy is detected. Reverts if `_stake` fails (e.g., zero amount, transfer fails)."
  },
  "RewardVault_V0.delegateStake": {
    "type": "external",
    "function_name": "delegateStake(address account, uint256 amount)",
    "analysis_result": "Purpose: Allows `msg.sender` (a delegate) to stake `stakeToken` on behalf of a specified `account`. Variables Used: Inherited state (`totalSupply`, `_accountInfo`, etc.), `_delegateStake` (written), potentially `stakeToken`. Internal/External Calls: Calls `_stake(account, amount)` (internal, inherited from StakingRewards). May involve external token transfer via `stakeToken.transferFrom`. Implicitly reverts with custom error (`NotDelegate`). Logic: Checks that `msg.sender` is not the `account`. Calls the internal `_stake` function with the target `account`. Updates `_delegateStake[account].delegateTotalStaked` and `_delegateStake[account].stakedByDelegate[msg.sender]` in an unchecked block. Events: May emit events from `_stake` (e.g., `Staked`, `RewardPaid`). Emits `DelegateStaked`. Modifiers Applied: `nonReentrant`, `whenNotPaused`. Error Conditions: Reverts if the contract is paused. Reverts if reentrancy is detected. Reverts with `NotDelegate` if `msg.sender` is the same as `account`. Reverts if `_stake` fails (e.g., zero amount, transfer fails)."
  },
  "RewardVault_V0.withdraw": {
    "type": "external",
    "function_name": "withdraw(uint256 amount)",
    "analysis_result": "Purpose: Allows user (`msg.sender`) to withdraw their *self-staked* `stakeToken` from the vault. Variables Used: Inherited state (`totalSupply`, `_accountInfo`, etc.), `_delegateStake` (read), potentially `stakeToken`. Internal/External Calls: Implicitly calls `_checkSelfStakedBalance(msg.sender, amount)` via modifier. Calls `_withdraw(msg.sender, amount)` (internal, inherited from StakingRewards). May involve external token transfer via `stakeToken.transfer`. Logic: Uses the `checkSelfStakedBalance` modifier to ensure sufficient self-staked funds. Calls the internal `_withdraw` function inherited from `StakingRewards` with `msg.sender` as the account. Handles core withdrawal logic, including updating balances and total supply. Events: May emit events from `_withdraw` (e.g., `Withdrawn`, `RewardPaid`). Modifiers Applied: `nonReentrant`, `checkSelfStakedBalance(msg.sender, amount)`. Error Conditions: Reverts if reentrancy is detected. Reverts if `checkSelfStakedBalance` fails (insufficient self-staked amount). Reverts if `_withdraw` fails (e.g., zero amount, amount exceeds total staked, transfer fails)."
  },
  "RewardVault_V0.delegateWithdraw": {
    "type": "external",
    "function_name": "delegateWithdraw(address account, uint256 amount)",
    "analysis_result": "Purpose: Allows `msg.sender` (a delegate) to withdraw `stakeToken` that they *personally staked* on behalf of the specified `account`. Variables Used: `_delegateStake` (written), inherited state (`totalSupply`, `_accountInfo`, etc.), potentially `stakeToken`. Internal/External Calls: Calls `_withdraw(account, amount)` (internal, inherited from StakingRewards). May involve external token transfer via `stakeToken.transfer`. Implicitly reverts with custom errors (`NotDelegate`, `InsufficientDelegateStake`). Logic: Checks that `msg.sender` is not the `account`. Checks if the `msg.sender` has enough `amount` staked for the `account` in `_delegateStake[account].stakedByDelegate[msg.sender]`. If sufficient, decrements delegate stake counts (`stakedByDelegate` and `delegateTotalStaked`) in an unchecked block. Calls the internal `_withdraw` function with the target `account`. Events: May emit events from `_withdraw` (e.g., `Withdrawn`, `RewardPaid`). Emits `DelegateWithdrawn`. Modifiers Applied: `nonReentrant`. Error Conditions: Reverts if reentrancy is detected. Reverts with `NotDelegate` if `msg.sender` is the same as `account`. Reverts with `InsufficientDelegateStake` if the delegate has not staked the requested `amount` for the account. Reverts if `_withdraw` fails (e.g., zero amount, amount exceeds total staked for the account, transfer fails)."
  },
  "RewardVault_V0.getReward": {
    "type": "external",
    "function_name": "getReward(address account, address recipient)",
    "analysis_result": "Purpose: Allows a specified `account` or their operator (`_operators[account]`) to claim pending BGT rewards, sending them to a specified `recipient`. Incentive distribution is handled separately during BGT emission. Variables Used: Inherited state (`_accountInfo`, `rewardToken`, etc.). Internal/External Calls: Calls `_getReward(account, recipient)` (internal, inherited from StakingRewards). May involve external token transfer via `rewardToken.transfer`. Implicitly reverts with custom error (`NotOperator`). Logic: Uses the `onlyOperatorOrUser(account)` modifier to authorize the caller. Calls the internal `_getReward` function inherited from `StakingRewards`, which calculates pending BGT rewards for the `account`, updates reward state, and transfers BGT to the `recipient`. Returns the amount of BGT claimed. Events: May emit events from `_getReward` (e.g., `RewardPaid`). Modifiers Applied: `nonReentrant`, `onlyOperatorOrUser(account)`. Error Conditions: Reverts if reentrancy is detected. Reverts if called by an address that is not the `account` or its operator. Reverts if `_getReward` fails (e.g., transfer fails)."
  },
  "RewardVault_V0.exit": {
    "type": "external",
    "function_name": "exit(address recipient)",
    "analysis_result": "Purpose: Allows the `msg.sender` to withdraw all their *self-staked* `stakeToken` and claim all pending BGT rewards, sending everything to a specified `recipient`. Incentive distribution is handled separately during BGT emission. Variables Used: Inherited state (`_accountInfo`, `totalSupply`, `rewardToken`, etc.), `_delegateStake` (read), potentially `stakeToken`. Internal/External Calls: Calls `_withdraw(msg.sender, amount)` (internal, inherited from StakingRewards), `_getReward(msg.sender, recipient)` (internal, inherited from StakingRewards). May involve external token transfers. Logic: Calculates the amount of self-staked tokens for `msg.sender`. Calls `_withdraw` to withdraw this amount. Calls `_getReward` to claim pending BGT rewards. Events: May emit events from `_withdraw` and `_getReward` (e.g., `Withdrawn`, `RewardPaid`). Modifiers Applied: `nonReentrant`. Error Conditions: Reverts if reentrancy is detected. Reverts if `_withdraw` fails (e.g., transfer fails). Reverts if `_getReward` fails (e.g., transfer fails)."
  },
  "RewardVault_V0.setOperator": {
    "type": "external",
    "function_name": "setOperator(address _operator)",
    "analysis_result": "Purpose: Allows the `msg.sender` to designate an `_operator` address that is authorized to perform certain actions (like claiming rewards) on their behalf. Variables Used: `_operators` (written). Internal/External Calls: None. Logic: Sets the entry for `msg.sender` in the `_operators` mapping to the provided `_operator` address. Events: Emits `OperatorSet`. Modifiers Applied: None. Error Conditions: None."
  },
  "RewardVault_V0.addIncentive": {
    "type": "external",
    "function_name": "addIncentive(address token, uint256 amount, uint256 incentiveRate)",
    "analysis_result": "Purpose: Allows the designated manager for a whitelisted incentive `token` to add more incentive tokens to the contract and potentially update the `incentiveRate`. Variables Used: `incentives` (read/written), `MAX_INCENTIVE_RATE` (read). Internal/External Calls: External call to `IERC20(token).safeTransferFrom(msg.sender, address(this), amount)` using SafeERC20. Uses `FixedPointMathLib.mulDiv`, `FixedPointMathLib.min`. Implicitly reverts with custom errors (`IncentiveRateTooHigh`, `NotIncentiveManager`, `AmountLessThanMinIncentiveRate`). Logic: Uses `onlyWhitelistedToken` to ensure the token is valid. Checks rate limits. Verifies `msg.sender` is the token's manager. Checks if `amount` is less than `minIncentiveRate`. Transfers the `amount` of the incentive token from `msg.sender` to the contract. Increases `amountRemaining`. Updates `incentiveRate` if criteria are met (either remaining amount was zero and new rate is >= min rate, or new rate is higher and sufficient amount is added to maintain the old BGT incentive capacity). Events: Emits `IncentiveAdded`. Modifiers Applied: `nonReentrant`, `onlyWhitelistedToken(token)`. Error Conditions: Reverts if reentrancy is detected. Reverts with `TokenNotWhitelisted` if the token is not whitelisted. Reverts with `IncentiveRateTooHigh` if `incentiveRate` exceeds `MAX_INCENTIVE_RATE`. Reverts with `NotIncentiveManager` if `msg.sender` is not the manager for the token. Reverts with `AmountLessThanMinIncentiveRate` if `amount` is less than `minIncentiveRate`. Reverts if `safeTransferFrom` fails."
  },
  "RewardVault_V0._checkSelfStakedBalance": {
    "type": "internal view",
    "function_name": "_checkSelfStakedBalance(address account, uint256 amount)",
    "analysis_result": "Purpose: Helper function used by the `checkSelfStakedBalance` modifier to calculate and verify that an account has a sufficient amount of *self-staked* balance (total staked minus delegate staked) for a given `amount`. Variables Used: `_accountInfo` (read, inherited), `_delegateStake` (read). Internal/External Calls: Implicitly reverts with custom error (`InsufficientSelfStake`). Logic: Calculates the self-staked amount by subtracting `_delegateStake[account].delegateTotalStaked` from `_accountInfo[account].balance` in an unchecked block. Checks if the calculated `selfStaked` amount is less than the provided `amount`. If it is, reverts with `InsufficientSelfStake`. Events: None. Modifiers Applied: None. Error Conditions: Reverts with `InsufficientSelfStake` if the account's self-staked balance is less than the requested `amount`."
  },
  "RewardVault_V0._safeTransferRewardToken": {
    "type": "internal override",
    "function_name": "_safeTransferRewardToken(address to, uint256 amount)",
    "analysis_result": "Purpose: Internal helper function used by the `StakingRewards` base contract to perform the BGT reward token transfer. This overridden version uses `safeTransferFrom` to pull tokens from the `distributor`'s allowance to this contract. Variables Used: `distributor` (read), `rewardToken` (read, inherited). Internal/External Calls: External call to `rewardToken.safeTransferFrom(distributor, to, amount)` using SafeERC20. Logic: Transfers `amount` of the `rewardToken` from the `distributor` address to the `to` address, relying on an existing allowance from the `distributor` to the contract. Events: May emit standard ERC20 transfer events. Modifiers Applied: None. Error Conditions: Reverts if `safeTransferFrom` fails (e.g., insufficient allowance, insufficient balance, token transfer issue)."
  },
  "RewardVault_V0._checkRewardSolvency": {
    "type": "internal view override",
    "function_name": "_checkRewardSolvency()",
    "analysis_result": "Purpose: Internal helper function used by the `StakingRewards` base contract to check if the total `undistributedRewards` is theoretically coverable by the `distributor`'s allowance to the contract. This prevents reward calculation overflows by ensuring the effective total reward amount doesn't become too large. Variables Used: `rewardToken` (read, inherited), `distributor` (read), `undistributedRewards` (read, inherited), `PRECISION` (read, inherited). Internal/External Calls: External call to `rewardToken.allowance(distributor, address(this))`. Implicitly reverts with custom error (`InsolventReward`). Logic: Retrieves the `distributor`'s allowance to the contract for the `rewardToken`. Compares `undistributedRewards / PRECISION` (effectively the number of full reward tokens represented by `undistributedRewards`) with the allowance. If the former exceeds the latter, it indicates potential insolvency risk and reverts with `InsolventReward`. Events: None. Modifiers Applied: None. Error Conditions: Reverts with `InsolventReward` if the calculated reward amount exceeds the distributor's allowance."
  },
  "RewardVault_V0._processIncentives": {
    "type": "internal",
    "function_name": "_processIncentives(bytes calldata pubkey, uint256 bgtEmitted)",
    "analysis_result": "Purpose: Distributes whitelisted incentive tokens to the operator of the validator associated with the provided `pubkey`, based on the amount of `bgtEmitted`. Variables Used: `beaconDepositContract` (read), `whitelistedTokens` (read), `incentives` (read/written). Internal/External Calls: External call to `beaconDepositContract.getOperator(pubkey)`. External call to `token.trySafeTransfer(_operator, amount)` using SafeERC20. Uses `FixedPointMathLib.mulDiv`, `FixedPointMathLib.min`. Logic: Retrieves the validator's operator address from `beaconDepositContract`. Iterates through the `whitelistedTokens`. For each token, calculates the potential incentive amount based on `bgtEmitted` and the token's `incentiveRate`. Limits this amount to the currently `amountRemaining` for that token. If the amount is greater than 0, it attempts to transfer the incentive token amount to the operator using `trySafeTransfer`. If the transfer succeeds, updates the `amountRemaining`. Emits `IncentivesProcessed` on success, `IncentivesProcessFailed` on failure. Events: Emits `IncentivesProcessed`, `IncentivesProcessFailed`. Modifiers Applied: None. Error Conditions: Transfers that fail are caught by `trySafeTransfer` and logged via an event rather than reverting the entire transaction."
  },
  "RewardVault_V0._deleteWhitelistedTokenFromList": {
    "type": "internal",
    "function_name": "_deleteWhitelistedTokenFromList(address token)",
    "analysis_result": "Purpose: Helper function to remove a specific `token` address from the dynamic `whitelistedTokens` array efficiently. Variables Used: `whitelistedTokens` (written). Internal/External Calls: None. Logic: Iterates through the `whitelistedTokens` array to find the index of the target `token`. Once found, it replaces the element at that index with the last element of the array and then removes the last element using `.pop()`, effectively removing the target token. Events: None. Modifiers Applied: None. Error Conditions: Assumes the token exists in the list (typically guaranteed by the `onlyWhitelistedToken` modifier on the calling function)."
  },
  "RewardVaultFactory_V0.constructor": {
    "type": "public",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor for the contract. It is marked with `custom:oz-upgrades-unsafe-allow constructor` and calls `_disableInitializers()` from the `UUPSUpgradeable` base contract. Its purpose is to prevent the `initialize` function from being called multiple times during deployment and setup within an upgradeable proxy pattern. It does not use or modify any state variables directly."
  },
  "RewardVaultFactory_V0.initialize": {
    "type": "external",
    "function_name": "initialize(address _bgt, address _distributor, address _beaconDepositContract, address _governance, address _vaultImpl) external initializer",
    "analysis_result": "This external function is marked with the `initializer` modifier, ensuring it can only be called once. It performs the primary setup of the factory contract. It initializes the `AccessControlUpgradeable` and `UUPSUpgradeable` base contracts. It grants the `DEFAULT_ADMIN_ROLE` to the provided `_governance` address. It sets the `VAULT_MANAGER_ROLE` as the administrative role for the `VAULT_PAUSER_ROLE`, allowing vault managers to grant/revoke pauser permissions. It assigns the input addresses `_bgt`, `_distributor`, and `_beaconDepositContract` to the corresponding state variables `bgt`, `distributor`, and `beaconDepositContract` (zero address checks are intentionally skipped per comment). Finally, it deploys a new `UpgradeableBeacon` contract with `_governance` as the owner and `_vaultImpl` as the initial implementation, storing the beacon's address in the `beacon` state variable. It uses and modifies state variables: `bgt`, `distributor`, `beaconDepositContract`, and `beacon`. It calls inherited initializer functions and deploys a new contract `UpgradeableBeacon`."
  },
  "RewardVaultFactory_V0._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation) internal override onlyRole(DEFAULT_ADMIN_ROLE)",
    "analysis_result": "This internal function overrides the required function from `UUPSUpgradeable`. It controls who is authorized to initiate contract upgrades. It is protected by the `onlyRole(DEFAULT_ADMIN_ROLE)` modifier, meaning only addresses possessing the `DEFAULT_ADMIN_ROLE` can successfully execute this function (and thus trigger an upgrade via the UUPS proxy). The function body itself is empty; the authorization logic is entirely within the `onlyRole` modifier. It does not use or modify state variables within its body, but relies on the `DEFAULT_ADMIN_ROLE` definition managed by the `AccessControlUpgradeable` base contract."
  },
  "RewardVaultFactory_V0.createRewardVault": {
    "type": "external",
    "function_name": "createRewardVault(address stakingToken) external returns (address)",
    "analysis_result": "This external function creates a new RewardVault proxy contract for a specific `stakingToken` if one does not already exist. It first checks the `getVault` mapping using `stakingToken` to see if a vault address is already stored; if so, it returns the existing address. If no vault exists, it checks if `stakingToken` is a contract by examining its code length; if it's not a contract (code length is 0), it reverts using `NotAContract.selector.revertWith()` from the imported `Utils` library. It calculates a deterministic salt based on the `stakingToken` address using `keccak256` in an assembly block. It then uses `LibClone.deployDeterministicERC1967BeaconProxy` from the Solady library to deploy a new ERC1967 proxy contract linked to the `beacon` and using the calculated salt. The address of the newly deployed proxy is stored in the `getVault` mapping keyed by `stakingToken` and is also added to the `allVaults` array. A `VaultCreated` event is emitted with the `stakingToken` and new vault addresses. Finally, it calls the `initialize` function on the newly created vault proxy, passing the `beaconDepositContract`, `bgt`, `distributor`, and `stakingToken` addresses for the vault's setup. It uses and modifies state variables: `getVault`, `allVaults`, and `beacon` (used in deployment). It calls `stakingToken.code.length`, `NotAContract.selector.revertWith()`, `LibClone.deployDeterministicERC1967BeaconProxy()`, `allVaults.push()`, and `RewardVault_V0(vault).initialize()`. It emits the `VaultCreated` event."
  },
  "RewardVaultFactory_V0.predictRewardVaultAddress": {
    "type": "external",
    "function_name": "predictRewardVaultAddress(address stakingToken) external view returns (address)",
    "analysis_result": "This external view function calculates and returns the deterministic address that a RewardVault proxy would have for a given `stakingToken`, without actually deploying the vault. It calculates the same deterministic salt based on the `stakingToken` address using `keccak256` in an assembly block, identical to the salt calculation in `createRewardVault`. It then uses `LibClone.predictDeterministicAddressERC1967BeaconProxy` from the Solady library, providing the `beacon` address, the calculated salt, and the factory's own address (`address(this)`) as the deployer context. It returns the predicted address. It uses the state variable `beacon`. It calls `LibClone.predictDeterministicAddressERC1967BeaconProxy()`."
  },
  "RewardVaultFactory_V0.allVaultsLength": {
    "type": "external",
    "function_name": "allVaultsLength() external view returns (uint256)",
    "analysis_result": "This external view function returns the total number of RewardVault proxy contracts that have been successfully created and registered by this factory. It achieves this by returning the current length of the `allVaults` array. It reads from the state variable `allVaults`."
  },
  "VaultAdmin_V0.__VaultAdmin_init": {
    "type": "internal",
    "function_name": "__VaultAdmin_init(address _governance, address _polFeeCollector, address _feeReceiver)",
    "analysis_result": "Purpose: This is the main initializer for the VaultAdmin_V0 contract, designed for upgradeable proxies (UUPS). It calls initializers from inherited contracts and then calls the unchained initializer for specific VaultAdmin logic. Logic: Calls `__AccessControl_init()` to set up role-based access control. Calls `__Pausable_init()` to set up the pausing mechanism. Calls `__UUPSUpgradeable_init()` to set up the UUPS upgradeability. Calls `__VaultAdmin_init_unchained()` to perform VaultAdmin-specific initialization. Sets the admin role for the `PAUSER_ROLE` to the `MANAGER_ROLE`, meaning addresses with the `MANAGER_ROLE` can grant or revoke the `PAUSER_ROLE`. Variables Used: No direct state variable writes here, but initializes inherited contracts. External Calls: Calls initializers of `AccessControlUpgradeable`, `PausableUpgradeable`, and `UUPSUpgradeable`. Calls `__VaultAdmin_init_unchained`. Calls `_setRoleAdmin` from `AccessControlUpgradeable`. Events Emitted: None directly, but sub-initializers might emit events. Access Control: Uses `onlyInitializing` modifier, restricting calls only during the initialization phase of a proxy deployment. Error Handling: None specified within this function; errors would come from sub-initializers or `__VaultAdmin_init_unchained`. Specific Details: Follows the common OpenZeppelin upgradeable pattern with chained initializers. The `_setRoleAdmin` call establishes a hierarchy where the MANAGER can manage the PAUSER role."
  },
  "VaultAdmin_V0.__VaultAdmin_init_unchained": {
    "type": "internal",
    "function_name": "__VaultAdmin_init_unchained(address _governance, address _polFeeCollector, address _feeReceiver)",
    "analysis_result": "Purpose: Performs the core initialization steps specific to the VaultAdmin_V0 contract, separate from inherited contract initializers. Logic: Checks if `_governance`, `_polFeeCollector`, or `_feeReceiver` are zero addresses, reverting if any are. Deploys a new `UpgradeableBeacon` contract, setting the initial implementation to a new instance of `CollateralVault_V0`. The `_governance` address is passed to the `UpgradeableBeacon` constructor as its owner. Grants the `DEFAULT_ADMIN_ROLE` to the `_governance` address using `_grantRole` from `AccessControlUpgradeable`. Sets the `feeReceiver` state variable to `_feeReceiver`. Sets the `polFeeCollector` state variable to `_polFeeCollector`. Variables Used: Reads `_governance`, `_polFeeCollector`, `_feeReceiver`. Writes `beacon`, `feeReceiver`, `polFeeCollector`. External Calls: Calls `revertWith` on `ZeroAddress.selector` if input addresses are zero. Deploys `UpgradeableBeacon` and `CollateralVault_V0`. Calls `_grantRole` from `AccessControlUpgradeable`. Events Emitted: `FeeReceiverSet`, `POLFeeCollectorSet`. Access Control: Uses `onlyInitializing` modifier, restricting calls only during initialization. Error Handling: Reverts with `ZeroAddress` error if any input address is address(0). Specific Details: Deploys a beacon for managing vault implementations. Assigns key administrative roles and addresses (`DEFAULT_ADMIN_ROLE`, `feeReceiver`, `polFeeCollector`). Emits events to signal the setup of fee addresses."
  },
  "VaultAdmin_V0._checkRegisteredAsset": {
    "type": "internal",
    "function_name": "_checkRegisteredAsset(address asset)",
    "analysis_result": "Purpose: Internal helper function to verify if a given asset address has a corresponding vault registered in the `vaults` mapping. Logic: Looks up the `asset` in the `vaults` mapping. If the returned address is the zero address (meaning no vault is associated with this asset), it reverts. Variables Used: Reads `vaults`. External Calls: Calls `revertWith` on `AssetNotRegistered.selector`. Events Emitted: None. Access Control: Internal function, called by other functions within the contract. Error Handling: Reverts with `AssetNotRegistered` error, including the `asset` address, if `vaults[asset]` is address(0). Specific Details: Essential pre-condition check for functions that operate on registered assets/vaults."
  },
  "VaultAdmin_V0._checkGoodCollateralAsset": {
    "type": "internal",
    "function_name": "_checkGoodCollateralAsset(address asset)",
    "analysis_result": "Purpose: Internal helper function to verify if a given asset address is NOT marked as 'bad collateral'. Logic: Looks up the `asset` in the `isBadCollateralAsset` mapping. If the value is `true`, it reverts. Variables Used: Reads `isBadCollateralAsset`. External Calls: Calls `revertWith` on `AssetIsBadCollateral.selector`. Events Emitted: None. Access Control: Internal function, called by other functions within the contract. Error Handling: Reverts with `AssetIsBadCollateral` error, including the `asset` address, if `isBadCollateralAsset[asset]` is `true`. Specific Details: Used as a safeguard, presumably before allowing operations like minting that rely on the asset being considered 'good' collateral."
  },
  "VaultAdmin_V0._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "Purpose: Override of the `UUPSUpgradeable` internal function to define the contract's upgrade authorization policy. Logic: This function is called by the `UUPSUpgradeable` base contract's `_upgradeToAndCall` or `_upgradeTo` when an upgrade is requested. It implements the check for who is allowed to trigger the upgrade. In this implementation, it simply checks if the caller has the `DEFAULT_ADMIN_ROLE`. The `newImplementation` parameter is marked as unused with a silent warning comment. Variables Used: None directly. External Calls: Calls `_checkRole(DEFAULT_ADMIN_ROLE)` from `AccessControlUpgradeable`. Events Emitted: None. Access Control: Uses `internal virtual override`, restricting calls to the contract itself or derived contracts, and is part of the UUPS flow. Authorization check is enforced via `_checkRole(DEFAULT_ADMIN_ROLE)`. Error Handling: Reverts if the caller does not have the `DEFAULT_ADMIN_ROLE` due to the `_checkRole` call. Specific Details: Implements the UUPS access control logic, ensuring only the default admin can initiate contract upgrades."
  },
  "VaultAdmin_V0.pause": {
    "type": "external",
    "function_name": "pause()",
    "analysis_result": "Purpose: Pauses the VaultAdmin contract, preventing specific operations regulated by the `Pausable` modifier (like `whenNotPaused`). Logic: Checks if the caller has the `PAUSER_ROLE` using `_checkRole`. If the role check passes, it calls the internal `_pause()` function inherited from `PausableUpgradeable`. Variables Used: None directly, interacts with `PausableUpgradeable` state. External Calls: Calls `_checkRole(PAUSER_ROLE)` from `AccessControlUpgradeable`. Calls `_pause()` from `PausableUpgradeable`. Events Emitted: Emits a Paused event via `_pause()`. Access Control: Uses `external` visibility. Restricted by `_checkRole(PAUSER_ROLE)`, meaning only accounts with the PAUSER role can call this function. Error Handling: Reverts if the caller does not have the `PAUSER_ROLE`. Reverts if the contract is already paused (handled by `_pause()`). Specific Details: Provides a mechanism to halt sensitive operations governed by `whenNotPaused` modifier on the VaultAdmin contract itself."
  },
  "VaultAdmin_V0.unpause": {
    "type": "external",
    "function_name": "unpause()",
    "analysis_result": "Purpose: Unpauses the VaultAdmin contract, allowing operations regulated by the `Pausable` modifier (like `whenNotPaused`) to proceed. Logic: Checks if the caller has the `MANAGER_ROLE` using `_checkRole`. If the role check passes, it calls the internal `_unpause()` function inherited from `PausableUpgradeable`. Variables Used: None directly, interacts with `PausableUpgradeable` state. External Calls: Calls `_checkRole(MANAGER_ROLE)` from `AccessControlUpgradeable`. Calls `_unpause()` from `PausableUpgradeable`. Events Emitted: Emits an Unpaused event via `_unpause()`. Access Control: Uses `external` visibility. Restricted by `_checkRole(MANAGER_ROLE)`, meaning only accounts with the MANAGER role can call this function. Error Handling: Reverts if the caller does not have the `MANAGER_ROLE`. Reverts if the contract is not paused (handled by `_unpause()`). Specific Details: Provides a mechanism to resume sensitive operations on the VaultAdmin contract. Note that `PAUSER_ROLE` can pause, but only `MANAGER_ROLE` can unpause, creating a permission hierarchy."
  },
  "VaultAdmin_V0.pauseVault": {
    "type": "external",
    "function_name": "pauseVault(address asset)",
    "analysis_result": "Purpose: Pauses a specific collateral vault associated with a given asset. Logic: Checks if the caller has the `PAUSER_ROLE` using `_checkRole`. Calls the internal helper function `_checkRegisteredAsset` to ensure a vault exists for the specified `asset`. Retrieves the vault address from the `vaults` mapping. Casts the vault address to `CollateralVault_V0` and calls its `pause()` function. Variables Used: Reads `vaults`. External Calls: Calls `_checkRole(PAUSER_ROLE)`. Calls `_checkRegisteredAsset(asset)`. Calls `pause()` on the `CollateralVault_V0` instance. Events Emitted: The called `vault.pause()` function likely emits a Paused event. Access Control: Uses `external` visibility. Restricted by `_checkRole(PAUSER_ROLE)`. Error Handling: Reverts if the caller does not have the `PAUSER_ROLE`. Reverts if the `asset` is not registered via `_checkRegisteredAsset`. Reverts if the vault for the asset is already paused (handled by the vault's `pause()` function). Specific Details: Allows fine-grained control over individual vaults' operational status. Only the `PAUSER_ROLE` can perform this action."
  },
  "VaultAdmin_V0.unpauseVault": {
    "type": "external",
    "function_name": "unpauseVault(address asset)",
    "analysis_result": "Purpose: Unpauses a specific collateral vault associated with a given asset. Logic: Checks if the caller has the `MANAGER_ROLE` using `_checkRole`. Calls the internal helper function `_checkRegisteredAsset` to ensure a vault exists for the specified `asset`. Retrieves the vault address from the `vaults` mapping. Casts the vault address to `CollateralVault_V0` and calls its `unpause()` function. Variables Used: Reads `vaults`. External Calls: Calls `_checkRole(MANAGER_ROLE)`. Calls `_checkRegisteredAsset(asset)`. Calls `unpause()` on the `CollateralVault_V0` instance. Events Emitted: The called `vault.unpause()` function likely emits an Unpaused event. Access Control: Uses `external` visibility. Restricted by `_checkRole(MANAGER_ROLE)`. Error Handling: Reverts if the caller does not have the `MANAGER_ROLE`. Reverts if the `asset` is not registered via `_checkRegisteredAsset`. Reverts if the vault for the asset is not paused (handled by the vault's `unpause()` function). Specific Details: Allows fine-grained control over individual vaults' operational status. Only the `MANAGER_ROLE` can perform this action. Similar to the contract-level unpause, only the MANAGER can unpause vaults, while the PAUSER can pause them."
  },
  "VaultAdmin_V0._createVault": {
    "type": "internal",
    "function_name": "_createVault(address asset)",
    "analysis_result": "Purpose: Internal function to create and initialize a new `CollateralVault_V0` instance for a given asset using a deterministic beacon proxy. Logic: Checks if the caller has the `DEFAULT_ADMIN_ROLE` using `_checkRole`. Checks if a vault for the given `asset` is already registered in the `vaults` mapping, reverting if one exists. Adds the `asset` to the `registeredAssets` array. Calculates a deterministic salt for deploying the proxy based on the `asset` address using assembly. Uses `LibClone.deployDeterministicERC1967BeaconProxy` to deploy a new proxy instance linked to the `beacon` and using the calculated `salt`. Casts the deployed proxy address to `CollateralVault_V0`. Calls the `initialize` function on the newly deployed vault proxy, passing the `asset` address and the address of the `VaultAdmin_V0` contract itself. Stores the deployed vault address in the `vaults` mapping for the given `asset`. Emits the `VaultCreated` event. Returns the newly created vault contract instance. Variables Used: Reads `vaults`, `beacon`. Writes `registeredAssets`, `vaults`. External Calls: Calls `_checkRole(DEFAULT_ADMIN_ROLE)`. Calls `revertWith` on `VaultAlreadyRegistered.selector`. Uses assembly for salt calculation. Calls `LibClone.deployDeterministicERC1967BeaconProxy`. Calls `initialize` on the new vault instance. Events Emitted: `VaultCreated`. Access Control: Uses `internal` visibility. Restricted by `_checkRole(DEFAULT_ADMIN_ROLE)`. Error Handling: Reverts if the caller does not have the `DEFAULT_ADMIN_ROLE`. Reverts with `VaultAlreadyRegistered` error if a vault for the asset already exists. Specific Details: This function is key to the system's scalability, allowing new vaults to be created dynamically for different collateral assets using a beacon proxy pattern. The deterministic deployment ensures the vault address is predictable for a given asset and salt (which is also derived from the asset). The vault is initialized with its associated asset and a reference back to the admin contract."
  },
  "VaultAdmin_V0.setFeeReceiver": {
    "type": "external",
    "function_name": "setFeeReceiver(address _feeReceiver)",
    "analysis_result": "Purpose: Sets the address that will receive protocol fees. Logic: Checks if the caller has the `DEFAULT_ADMIN_ROLE` using `_checkRole`. Checks if the provided `_feeReceiver` address is zero, reverting if it is. Updates the `feeReceiver` state variable to the new address. Emits the `FeeReceiverSet` event. Variables Used: Reads `_feeReceiver`. Writes `feeReceiver`. External Calls: Calls `_checkRole(DEFAULT_ADMIN_ROLE)`. Calls `revertWith` on `ZeroAddress.selector`. Events Emitted: `FeeReceiverSet`. Access Control: Uses `external` visibility. Restricted by `_checkRole(DEFAULT_ADMIN_ROLE)`. Error Handling: Reverts if the caller does not have the `DEFAULT_ADMIN_ROLE`. Reverts with `ZeroAddress` error if `_feeReceiver` is address(0). Specific Details: Allows the administrator to change the recipient of accumulated fees."
  },
  "VaultAdmin_V0.setPOLFeeCollector": {
    "type": "external",
    "function_name": "setPOLFeeCollector(address _polFeeCollector)",
    "analysis_result": "Purpose: Sets the address designated for collecting POL (Protocol Owned Liquidity) fees. Logic: Checks if the caller has the `DEFAULT_ADMIN_ROLE` using `_checkRole`. Checks if the provided `_polFeeCollector` address is zero, reverting if it is. Updates the `polFeeCollector` state variable to the new address. Emits the `POLFeeCollectorSet` event. Variables Used: Reads `_polFeeCollector`. Writes `polFeeCollector`. External Calls: Calls `_checkRole(DEFAULT_ADMIN_ROLE)`. Calls `revertWith` on `ZeroAddress.selector`. Events Emitted: `POLFeeCollectorSet`. Access Control: Uses `external` visibility. Restricted by `_checkRole(DEFAULT_ADMIN_ROLE)`. Error Handling: Reverts if the caller does not have the `DEFAULT_ADMIN_ROLE`. Reverts with `ZeroAddress` error if `_polFeeCollector` is address(0). Specific Details: Allows the administrator to change the recipient specifically for POL fees."
  },
  "VaultAdmin_V0.setCollateralAssetStatus": {
    "type": "external",
    "function_name": "setCollateralAssetStatus(address asset, bool _isBadCollateral)",
    "analysis_result": "Purpose: Marks or unmarks an asset as 'bad collateral', which affects operations like minting within the associated vault. Logic: Checks if the caller has the `MANAGER_ROLE` using `_checkRole`. Calls the internal helper function `_checkRegisteredAsset` to ensure a vault exists for the specified `asset`. Updates the `isBadCollateralAsset` mapping for the given `asset` to the value of `_isBadCollateral`. Emits the `CollateralAssetStatusSet` event. Variables Used: Reads `_isBadCollateral`. Writes `isBadCollateralAsset`. External Calls: Calls `_checkRole(MANAGER_ROLE)`. Calls `_checkRegisteredAsset(asset)`. Events Emitted: `CollateralAssetStatusSet`. Access Control: Uses `external` visibility. Restricted by `_checkRole(MANAGER_ROLE)`. Error Handling: Reverts if the caller does not have the `MANAGER_ROLE`. Reverts if the `asset` is not registered via `_checkRegisteredAsset`. Specific Details: Provides a safety switch for assets that are deemed problematic (e.g., due to price oracle issues, manipulation, etc.), allowing the protocol to disable minting using that asset. Only the `MANAGER_ROLE` has this authority."
  },
  "VaultAdmin_V0.withdrawAllFees": {
    "type": "external",
    "function_name": "withdrawAllFees(address receiver)",
    "analysis_result": "Purpose: Allows a designated receiver to withdraw all collected fees across all registered assets. Logic: Retrieves the total number of registered assets by calling `numRegisteredAssets()`. Iterates through the `registeredAssets` array from index 0 up to the number of registered assets. In each iteration, it gets the current `asset` address from the array. It calls the internal helper function `_withdrawCollectedFee` for the current `asset` and the specified `receiver`. Uses an unchecked increment for the loop counter `i`. Variables Used: Reads `registeredAssets`. Writes state via the called `_withdrawCollectedFee` function. External Calls: Calls `numRegisteredAssets()`. Calls `_withdrawCollectedFee(asset, receiver)` for each asset. Events Emitted: None directly, but `_withdrawCollectedFee` emits `CollectedFeeWithdrawn` for each asset processed. Access Control: Uses `external` visibility. There is no specific role check within this function, implying any address can attempt to withdraw *their* collected fees if they are the specified `receiver`. The receiver is an input parameter, meaning someone could call this function specifying their own address to collect fees accrued to them. Error Handling: Relies on `_withdrawCollectedFee` for specific asset withdrawal errors (e.g., asset not registered, though `_withdrawCollectedFee` checks this). Specific Details: This function provides a convenient way for a fee receiver (like the feeReceiver or polFeeCollector addresses) to claim all fees accumulated across all vaults with a single transaction."
  },
  "VaultAdmin_V0.withdrawFee": {
    "type": "external",
    "function_name": "withdrawFee(address asset, address receiver)",
    "analysis_result": "Purpose: Allows a designated receiver to withdraw collected fees for a *specific* asset. Logic: Calls the internal helper function `_checkRegisteredAsset` to ensure a vault exists for the specified `asset`. Calls the internal helper function `_withdrawCollectedFee` for the given `asset` and `receiver`. Returns the amount of assets withdrawn. Variables Used: Reads `asset`, `receiver`. Writes state via the called `_withdrawCollectedFee` function. External Calls: Calls `_checkRegisteredAsset(asset)`. Calls `_withdrawCollectedFee(asset, receiver)`. Events Emitted: None directly, but `_withdrawCollectedFee` emits `CollectedFeeWithdrawn`. Access Control: Uses `external` visibility. Similar to `withdrawAllFees`, there's no specific role check here. Any address can call this function specifying *their* address as the `receiver` to attempt to withdraw fees accrued to them for the specific `asset`. Error Handling: Reverts if the `asset` is not registered via `_checkRegisteredAsset`. Specific Details: Provides a way for a fee receiver to claim fees on an asset-by-asset basis."
  },
  "VaultAdmin_V0._withdrawCollectedFee": {
    "type": "internal",
    "function_name": "_withdrawCollectedFee(address asset, address receiver)",
    "analysis_result": "Purpose: Internal function to handle the actual withdrawal of collected fees (in shares) for a specific asset and receiver. Logic: Retrieves the amount of shares stored for the `receiver` and `asset` from the `collectedFees` mapping. Checks if converting these shares to assets results in zero assets using the vault's `convertToAssets` function. If zero assets, it returns 0, indicating nothing to withdraw. If there are assets to withdraw, it sets the `collectedFees[receiver][asset]` entry to 0, effectively zeroing out the shares claimed by this receiver for this asset. Decreases the `collectedAssetFees[asset]` total shares by the amount of shares withdrawn (uses unchecked subtraction, assuming consistency in how shares are tracked). Calls the `redeem` function on the specific vault (`vaults[asset]`), passing the shares to redeem, the `receiver` address (as the recipient of assets), and the `VaultAdmin_V0` contract's address (as the owner of shares being redeemed). Stores the returned amount of assets from the `redeem` call. Emits the `CollectedFeeWithdrawn` event. Returns the amount of assets withdrawn. Variables Used: Reads `collectedFees`, `vaults`. Writes `collectedFees`, `collectedAssetFees`. External Calls: Calls `convertToAssets` on the `CollateralVault_V0` instance. Calls `redeem` on the `CollateralVault_V0` instance. Events Emitted: `CollectedFeeWithdrawn`. Access Control: Uses `internal` visibility, called by `withdrawAllFees` and `withdrawFee`. Error Handling: Returns 0 if shares convert to 0 assets. Relies on the vault's `redeem` function for potential errors during the redemption/transfer process. Specific Details: This is the core logic for fee withdrawal. It manages the accounting of collected shares in the `collectedFees` and `collectedAssetFees` mappings and interacts directly with the corresponding vault to convert shares into the underlying asset and transfer them to the receiver. The unchecked subtraction for `collectedAssetFees` assumes that the total tracked in `collectedAssetFees` accurately reflects the sum of shares across all receivers in `collectedFees[asset]`, which should be upheld by the logic that adds shares to these mappings (logic not shown in this contract excerpt). The `redeem` function being called with `address(this)` as the owner implies the VaultAdmin contract itself holds the fee shares within the vault, and `redeem` transfers the corresponding assets to the `receiver` address."
  },
  "VaultAdmin_V0.numRegisteredAssets": {
    "type": "public",
    "function_name": "numRegisteredAssets()",
    "analysis_result": "Purpose: Provides the count of registered assets. Logic: Returns the length of the `registeredAssets` array. Variables Used: Reads `registeredAssets`. External Calls: None. Events Emitted: None. Access Control: Uses `public view` visibility, allowing anyone to call it. Error Handling: None. Specific Details: Simple getter function."
  },
  "VaultAdmin_V0._lookupRegistrationIndex": {
    "type": "internal",
    "function_name": "_lookupRegistrationIndex(address asset)",
    "analysis_result": "Purpose: Internal helper function to find the index of a registered asset within the `registeredAssets` array. Logic: Iterates through the `registeredAssets` array from index 0 up to its length. In each iteration, it compares the current element (`registeredAssets[i]`) with the provided `asset` address. If a match is found, it returns the current index `i`. If the loop finishes without finding a match, it means the asset is not in the array, and the function implicitly returns the default value for uint256 (0) if used in a context that expects a return value after the loop, but its primary use is likely in a context where finding the asset is expected after `_checkRegisteredAsset` confirms it's registered, or where the return value is explicitly checked/handled. Variables Used: Reads `registeredAssets`. External Calls: None. Events Emitted: None. Access Control: Uses `internal view` visibility. Error Handling: Does not explicitly revert if the asset is not found. It would return the loop's final `i` value (which would be `registeredAssets.length`) or 0 if the loop never runs or asset is at index 0. A caller would need to check the returned index or precede the call with `_checkRegisteredAsset` if finding a registered asset is critical. Specific Details: Provides a way to get the position of an asset in the registration array, although this specific implementation might be inefficient for large arrays due to linear search. It's not used in the provided code excerpt."
  },
  "CollateralVault_V0.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor for the CollateralVault_V0 contract. It is marked with `/// @custom:oz-upgrades-unsafe-allow constructor` and calls `_disableInitializers()`. This pattern is used in upgradeable contracts to prevent the `initialize` function from being called multiple times, effectively marking the contract as 'initialized' in the context of the OpenZeppelin Upgrades plugin without performing any actual setup logic here. It does not access or modify any state variables directly, deferring setup to the `initialize` function."
  },
  "CollateralVault_V0.initialize": {
    "type": "external",
    "function_name": "initialize(address asset_, address _factory)",
    "analysis_result": "This is the primary initializer function for the contract, intended to be called once after deployment, typically via an upgradeable proxy. It is protected by the `initializer` modifier, which prevents subsequent calls. Its purpose is to set up the basic state of the vault. It first calls `__Pausable_init()` from the inherited PausableUpgradeable contract to initialize the pausing mechanism. Then, it calls the internal initializer `__CollateralVault_init(asset_, _factory)` to set the specific vault parameters. It requires two arguments: `asset_` (the address of the underlying ERC20 asset) and `_factory` (the address of the Honey factory contract that deployed this vault). It modifies state variables indirectly by calling other initializer functions."
  },
  "CollateralVault_V0.__CollateralVault_init": {
    "type": "internal",
    "function_name": "__CollateralVault_init(address asset_, address _factory)",
    "analysis_result": "This internal function performs the core initialization logic for the vault. It is called by the external `initialize` function and protected by the `onlyInitializing` modifier to ensure it runs only during the initialization process. It first checks if the provided `_factory` address is the zero address using `ZeroAddress.selector.revertWith()`, reverting if it is. It then stores the `_factory` address in the public `factory` state variable. It casts the `asset_` address to an `ERC20` instance and stores it in the private `_vaultAsset` state variable. It then calls the `name()` and `symbol()` functions on the `_vaultAsset` ERC20 contract and concatenates 'Vault' to them to set the private `_name` and `_symbol` state variables for the vault's own ERC20 token representation (shares). It modifies `factory`, `_vaultAsset`, `_name`, and `_symbol` state variables."
  },
  "CollateralVault_V0.onlyFactory": {
    "type": "modifier",
    "function_name": "onlyFactory()",
    "analysis_result": "This modifier restricts the execution of a function to only the address stored in the public `factory` state variable. It achieves this by calling the internal helper function `_checkFactory()`. It is used to enforce access control for sensitive administrative functions like pausing/unpausing and the core ERC4626 deposit/mint/withdraw/redeem operations."
  },
  "CollateralVault_V0.pause": {
    "type": "external",
    "function_name": "pause()",
    "analysis_result": "This external function allows the factory contract to pause the vault's operations. It uses the `onlyFactory` modifier to restrict access to the factory address and calls the internal `_pause()` function (inherited from PausableUpgradeable) to set the vault's paused state. This function modifies the inherited `_paused` state variable via the `_pause()` call."
  },
  "CollateralVault_V0.unpause": {
    "type": "external",
    "function_name": "unpause()",
    "analysis_result": "This external function allows the factory contract to unpause the vault's operations. It uses the `onlyFactory` modifier to restrict access to the factory address and calls the internal `_unpause()` function (inherited from PausableUpgradeable) to clear the vault's paused state. This function modifies the inherited `_paused` state variable via the `_unpause()` call."
  },
  "CollateralVault_V0.deposit": {
    "type": "public",
    "function_name": "deposit(uint256 assets, address receiver) returns (uint256)",
    "analysis_result": "This public function allows the factory to deposit underlying `assets` into the vault and receive vault shares. It overrides the standard ERC4626 `deposit` function. It is protected by the `onlyFactory` modifier, ensuring only the factory can call it, and the `whenNotPaused` modifier, ensuring the vault is not paused. This restriction is explicitly stated as a protection against inflation attacks by limiting who can mint new shares. It calls the standard ERC4626 implementation via `super.deposit(assets, receiver)`, which handles the asset transfer from the caller to the vault and the minting of shares to the `receiver`. It returns the amount of shares minted. It interacts with the underlying `_vaultAsset` (transferring assets in) and modifies the vault's `_totalSupply` and the `receiver`'s share balance (`_balances`)."
  },
  "CollateralVault_V0.mint": {
    "type": "public",
    "function_name": "mint(uint256 shares, address receiver) returns (uint256)",
    "analysis_result": "This public function allows the factory to mint a specific amount of vault `shares` by depositing the equivalent amount of assets. It overrides the standard ERC4626 `mint` function. Like `deposit`, it's protected by the `onlyFactory` and `whenNotPaused` modifiers as part of the inflation attack protection strategy. It calls the standard ERC4626 implementation via `super.mint(shares, receiver)`, which calculates the required assets, handles the asset transfer from the caller to the vault, and mints the specified `shares` to the `receiver`. It returns the amount of assets required. It interacts with the underlying `_vaultAsset` (transferring assets in) and modifies the vault's `_totalSupply` and the `receiver`'s share balance (`_balances`)."
  },
  "CollateralVault_V0.withdraw": {
    "type": "public",
    "function_name": "withdraw(uint256 assets, address receiver, address owner) returns (uint256)",
    "analysis_result": "This public function allows the factory to withdraw a specific amount of underlying `assets` from the vault by burning the equivalent amount of shares from an `owner`. It overrides the standard ERC4626 `withdraw` function. It's protected by the `onlyFactory` and `whenNotPaused` modifiers, enforcing that only the factory can initiate withdrawals/redemptions as part of the inflation attack protection. It calls the standard ERC4626 implementation via `super.withdraw(assets, receiver, owner)`, which calculates the required shares to burn from `owner`, handles the asset transfer from the vault to `receiver`, and burns the shares from `owner`. It returns the amount of shares burned. It interacts with the underlying `_vaultAsset` (transferring assets out) and modifies the vault's `_totalSupply` and the `owner`'s share balance (`_balances`)."
  },
  "CollateralVault_V0.redeem": {
    "type": "public",
    "function_name": "redeem(uint256 shares, address receiver, address owner) returns (uint256)",
    "analysis_result": "This public function allows the factory to redeem a specific amount of vault `shares` from an `owner` and receive the equivalent amount of underlying assets. It overrides the standard ERC4626 `redeem` function. It's protected by the `onlyFactory` and `whenNotPaused` modifiers for inflation attack protection. It calls the standard ERC4626 implementation via `super.redeem(shares, receiver, owner)`, which calculates the equivalent assets, burns the specified `shares` from `owner`, and handles the asset transfer from the vault to `receiver`. It returns the amount of assets redeemed. It interacts with the underlying `_vaultAsset` (transfers assets out) and modifies the vault's `_totalSupply` and the `owner`'s share balance (`_balances`)."
  },
  "CollateralVault_V0.name": {
    "type": "public",
    "function_name": "name() view returns (string memory)",
    "analysis_result": "This public view function returns the ERC20 name of the vault's share token. It overrides the standard ERC20 `name()` function. It reads and returns the private `_name` state variable, which is set during initialization based on the underlying asset's name."
  },
  "CollateralVault_V0.symbol": {
    "type": "public",
    "function_name": "symbol() view returns (string memory)",
    "analysis_result": "This public view function returns the ERC20 symbol of the vault's share token. It overrides the standard ERC20 `symbol()` function. It reads and returns the private `_symbol` state variable, which is set during initialization based on the underlying asset's symbol."
  },
  "CollateralVault_V0.asset": {
    "type": "public",
    "function_name": "asset() view virtual returns (address)",
    "analysis_result": "This public view function returns the address of the underlying ERC20 asset token that the vault holds. It overrides the standard ERC4626 `asset()` function. It reads and returns the address stored in the private `_vaultAsset` state variable."
  },
  "CollateralVault_V0.convertToAssets": {
    "type": "public",
    "function_name": "convertToAssets(uint256 shares) view returns (uint256)",
    "analysis_result": "This public view function converts a quantity of vault `shares` into the equivalent quantity of underlying assets based on the current exchange rate. It overrides the standard ERC4626 `convertToAssets` function. It calls the internal helper function `_convertToAssets(shares)` to perform the actual conversion, which accounts for the decimal differences between the shares and the underlying asset. It relies on the `totalAssets()` and `totalSupply()` to determine the rate, but in this specific implementation, due to the fixed rate logic described in `totalAssets()`, the conversion is always 1:1 adjusted for decimals. It reads the `_vaultAsset` state variable (indirectly via `_convertToAssets`) to get asset decimal information."
  },
  "CollateralVault_V0.convertToShares": {
    "type": "public",
    "function_name": "convertToShares(uint256 assets) view returns (uint256)",
    "analysis_result": "This public view function converts a quantity of underlying `assets` into the equivalent quantity of vault shares based on the current exchange rate. It overrides the standard ERC4626 `convertToShares` function. It calls the internal helper function `_convertToShares(assets)` to perform the actual conversion, which accounts for the decimal differences. Similar to `convertToAssets`, the conversion is effectively 1:1 adjusted for decimals due to the vault's specific `totalAssets()` implementation. It reads the `_vaultAsset` state variable (indirectly via `_convertToShares`) to get asset decimal information."
  },
  "CollateralVault_V0.totalAssets": {
    "type": "public",
    "function_name": "totalAssets() view returns (uint256)",
    "analysis_result": "This public view function returns the total value of underlying assets managed by the vault, expressed in asset units. It overrides the standard ERC4626 `totalAssets()` function. This implementation is crucial for the vault's inflation attack protection strategy. Instead of returning the actual balance of the underlying asset held by the vault contract, it calculates and returns the asset equivalent of the *total supply* of the vault's shares using `_convertToAssets(totalSupply())`. This effectively fixes the asset/share exchange rate based on the amount of shares minted by the factory, ignoring any assets that might be transferred directly to the vault contract by external users. It reads the inherited `totalSupply()` state variable and the private `_vaultAsset` state variable (indirectly via `_convertToAssets`)."
  },
  "CollateralVault_V0._initialConvertToShares": {
    "type": "internal",
    "function_name": "_initialConvertToShares(uint256 assets) view returns (uint256 shares)",
    "analysis_result": "This internal view function is part of the ERC4626 standard, specifically used during the very first interaction (deposit or mint when total supply is zero). It converts an amount of `assets` into the corresponding amount of shares for this initial case. In this contract, it simply calls the private helper function `_convertToShares(assets)`, maintaining the fixed conversion logic from the start. It reads the `_vaultAsset` state variable (indirectly via `_convertToShares`) and the vault's own decimals."
  },
  "CollateralVault_V0._initialConvertToAssets": {
    "type": "internal",
    "function_name": "_initialConvertToAssets(uint256 shares) view returns (uint256 assets)",
    "analysis_result": "This internal view function is also part of the ERC4626 standard, potentially used during the very first redemption or withdrawal when total supply is zero. It converts an amount of `shares` into the corresponding amount of assets for this initial case. In this contract, it simply calls the private helper function `_convertToAssets(shares)`, maintaining the fixed conversion logic. It reads the `_vaultAsset` state variable (indirectly via `_convertToAssets`) and the vault's own decimals."
  },
  "CollateralVault_V0._convertToShares": {
    "type": "private",
    "function_name": "_convertToShares(uint256 assets) view returns (uint256 shares)",
    "analysis_result": "This private view helper function performs the core logic of converting an amount of underlying `assets` into an amount of vault shares, taking into account the decimal differences between the two tokens. It reads the vault's decimals (`decimals()`) and the underlying asset's decimals (`_vaultAsset.decimals()`). It calculates an exponent based on the decimal difference and performs multiplication or division to scale the `assets` amount correctly into `shares`. It uses `unchecked` arithmetic for the exponent calculation, assuming decimal values are reasonable. It reads the private `_vaultAsset` state variable and the vault's own decimals (inherited)."
  },
  "CollateralVault_V0._convertToAssets": {
    "type": "private",
    "function_name": "_convertToAssets(uint256 shares) view returns (uint256 assets)",
    "analysis_result": "This private view helper function performs the core logic of converting an amount of vault `shares` into an amount of underlying assets, taking into account the decimal differences between the two tokens. It reads the vault's decimals (`decimals()`) and the underlying asset's decimals (`_vaultAsset.decimals()`). It calculates an exponent based on the decimal difference and performs division or multiplication to scale the `shares` amount correctly into `assets`. It uses `unchecked` arithmetic for the exponent calculation. It reads the private `_vaultAsset` state variable and the vault's own decimals (inherited)."
  },
  "CollateralVault_V0._useVirtualShares": {
    "type": "internal",
    "function_name": "_useVirtualShares() pure returns (bool)",
    "analysis_result": "This internal pure function is part of the ERC4626 standard. It returns `false`, indicating that this vault uses actual ERC20 shares (`_balances` mapping) rather than a virtual balance system. It does not access or modify any state variables."
  },
  "CollateralVault_V0._requireNotPaused": {
    "type": "internal",
    "function_name": "_requireNotPaused() view override",
    "analysis_result": "This internal view function is part of the PausableUpgradeable standard, used by functions protected by `whenNotPaused`. It checks if the vault is currently paused. It calls the inherited `paused()` function (which reads the `_paused` state variable) and reverts with `VaultPaused.selector.revertWith(asset())` if the vault is paused. It reads the inherited `_paused` state variable."
  },
  "CollateralVault_V0._checkFactory": {
    "type": "internal",
    "function_name": "_checkFactory() view",
    "analysis_result": "This internal view helper function is used by the `onlyFactory` modifier. It checks if the `msg.sender` (the address that initiated the current transaction) is equal to the address stored in the public `factory` state variable. If they are not equal, it reverts the transaction with `NotFactory.selector.revertWith()`. It reads the public `factory` state variable."
  },
  "IRewardVaultFactory_V0.createRewardVault": {
    "type": "external",
    "function_name": "createRewardVault(address stakingToken)",
    "analysis_result": "This external function is designed to create a new reward vault contract. It takes the `stakingToken` address as input, which is the token that the newly created vault will manage. The documentation specifies that the implementation should revert if the provided `stakingToken` address is not a contract address. Upon successful creation, the function is intended to return the address of the newly deployed vault and emit the `VaultCreated` event, including the staking token address and the new vault's address. In an implementing contract, this function would typically use a deployment mechanism like `new` or `create2` to deploy an instance of a vault contract. The implementation would likely store the mapping between the `stakingToken` and the newly created vault address in a storage variable (e.g., a mapping from address to address) and potentially increment a counter for the total number of vaults."
  },
  "IRewardVaultFactory_V0.VAULT_MANAGER_ROLE": {
    "type": "external",
    "function_name": "VAULT_MANAGER_ROLE()",
    "analysis_result": "This external view function is designed to return a `bytes32` value that represents the identifier for the 'VAULT_MANAGER_ROLE'. This role is likely part of an access control system used by contracts created by this factory or the factory itself. The function does not take any parameters and is a view function, meaning it does not modify the state of the contract. An implementing contract would simply return a predefined constant or a stored `bytes32` value."
  },
  "IRewardVaultFactory_V0.VAULT_PAUSER_ROLE": {
    "type": "external",
    "function_name": "VAULT_PAUSER_ROLE()",
    "analysis_result": "This external view function is designed to return a `bytes32` value that represents the identifier for the 'VAULT_PAUSER_ROLE'. Similar to `VAULT_MANAGER_ROLE`, this role is likely used within an access control system, granting permissions related to pausing functionality in the vaults or factory. The function does not take any parameters and is a view function, meaning it does not modify the state of the contract. An implementing contract would simply return a predefined constant or a stored `bytes32` value."
  },
  "IRewardVaultFactory_V0.getVault": {
    "type": "external",
    "function_name": "getVault(address stakingToken)",
    "analysis_result": "This external view function is used to retrieve the address of the reward vault that was created for a specific `stakingToken`. It takes the `stakingToken` address as input. The function is a view function, indicating it reads the contract state but does not modify it. An implementing contract is expected to maintain a mapping (likely `mapping(address => address)`) where the key is the `stakingToken` address and the value is the corresponding vault address, and this function would query that mapping."
  },
  "IRewardVaultFactory_V0.allVaultsLength": {
    "type": "external",
    "function_name": "allVaultsLength()",
    "analysis_result": "This external view function is intended to return the total number of reward vaults that have been successfully created by the factory. It takes no parameters and is a view function, meaning it does not modify the state. An implementing contract would typically maintain a counter storage variable that is incremented each time a new vault is created, and this function would return the current value of that counter, or return the length of an array or data structure holding all vault addresses."
  },
  "IRewardVaultFactory_V0.predictRewardVaultAddress": {
    "type": "external",
    "function_name": "predictRewardVaultAddress(address stakingToken)",
    "analysis_result": "This external view function is used to deterministically predict the address of the reward vault that *would be* created for a given `stakingToken` address *before* the `createRewardVault` function is actually called. It takes the `stakingToken` address as input. This is typically achieved using the `create2` opcode in Solidity, which allows predicting an address based on the factory's address, a salt (often derived from the input parameters like `stakingToken`), and the init code of the contract being deployed. This function is a view function and does not modify the contract state."
  },
  "IBeraChef_V0.getActiveRewardAllocation": {
    "type": "external view",
    "function_name": "getActiveRewardAllocation(bytes calldata valPubkey) external view returns (RewardAllocation memory)",
    "analysis_result": "This function is a getter that returns the currently active reward allocation for the validator identified by 'valPubkey'. It takes the validator's public key as input ('valPubkey' of type bytes) and returns a 'RewardAllocation' struct from memory. The analysis is based on the function signature and the provided `@notice` comment, indicating its purpose is to retrieve the active allocation data."
  },
  "IBeraChef_V0.getQueuedRewardAllocation": {
    "type": "external view",
    "function_name": "getQueuedRewardAllocation(bytes calldata valPubkey) external view returns (RewardAllocation memory)",
    "analysis_result": "This function is a getter that returns the reward allocation currently queued but not yet active for the validator identified by 'valPubkey'. It takes the validator's public key as input ('valPubkey' of type bytes) and returns a 'RewardAllocation' struct from memory. The analysis is based on the function signature and the provided `@notice` comment, indicating its purpose is to retrieve the queued allocation data."
  },
  "IBeraChef_V0.getSetActiveRewardAllocation": {
    "type": "external view",
    "function_name": "getSetActiveRewardAllocation(bytes calldata valPubkey) external view returns (RewardAllocation memory)",
    "analysis_result": "This function is a getter that returns the reward allocation that the validator identified by 'valPubkey' has set, regardless of whether it is currently active or valid. It takes the validator's public key as input ('valPubkey' of type bytes) and returns a 'RewardAllocation' struct from memory. The `@dev` comment clarifies that this function will return the allocation set by the validator even if it does not meet the validity criteria (e.g., weights don't sum correctly, non-whitelisted receivers)."
  },
  "IBeraChef_V0.getDefaultRewardAllocation": {
    "type": "external view",
    "function_name": "getDefaultRewardAllocation() external view returns (RewardAllocation memory)",
    "analysis_result": "This function is a getter that returns the default reward allocation used for validators that have not set their own specific allocation. It takes no parameters and returns a 'RewardAllocation' struct from memory. The analysis is based on the function signature and the provided `@notice` comment, indicating its purpose is to retrieve the system-wide default allocation."
  },
  "IBeraChef_V0.isQueuedRewardAllocationReady": {
    "type": "external view",
    "function_name": "isQueuedRewardAllocationReady(bytes calldata valPubkey, uint256 blockNumber) external view returns (bool)",
    "analysis_result": "This function checks and returns a boolean indicating whether the queued reward allocation for a specific validator ('valPubkey') is ready to be activated at a given 'blockNumber'. Readiness is determined by internal logic, likely comparing the 'startBlock' of the queued allocation against the provided 'blockNumber' and considering the 'rewardAllocationBlockDelay'. It takes the validator's public key ('valPubkey') and the block number to check ('blockNumber') as inputs."
  },
  "IBeraChef_V0.isReady": {
    "type": "external view",
    "function_name": "isReady() external view returns (bool)",
    "analysis_result": "This function returns a boolean indicating whether the BeraChef contract is initialized and ready for use by dependent systems. The `@dev` comment specifies that it will return 'false' if the governance module has not yet set the default reward allocation. It takes no parameters."
  },
  "IBeraChef_V0.setMaxNumWeightsPerRewardAllocation": {
    "type": "external",
    "function_name": "setMaxNumWeightsPerRewardAllocation(uint8 _maxNumWeightsPerRewardAllocation) external",
    "analysis_result": "This function is an administrative function intended to set the maximum number of weight entries ('Weight' structs) allowed within the 'weights' array of a 'RewardAllocation' struct. It takes a single parameter, '_maxNumWeightsPerRewardAllocation' of type uint8, which specifies the new maximum limit. This function is expected to emit the 'MaxNumWeightsPerRewardAllocationSet' event upon successful execution."
  },
  "IBeraChef_V0.setRewardAllocationBlockDelay": {
    "type": "external",
    "function_name": "setRewardAllocationBlockDelay(uint64 _rewardAllocationBlockDelay) external",
    "analysis_result": "This function is an administrative function intended to set the minimum number of blocks that must pass between a reward allocation being queued and it becoming eligible for activation. It takes a single parameter, '_rewardAllocationBlockDelay' of type uint64, which specifies the new delay in blocks. This function is expected to emit the 'RewardAllocationBlockDelaySet' event upon successful execution."
  },
  "IBeraChef_V0.setVaultWhitelistedStatus": {
    "type": "external",
    "function_name": "setVaultWhitelistedStatus(address receiver, bool isWhitelisted, string memory metadata) external",
    "analysis_result": "This function is an administrative function used to manage the whitelist status of vault addresses that can receive rewards. It is explicitly noted as callable only by the governance module account. It takes three parameters: 'receiver' (address) which is the vault address, 'isWhitelisted' (bool) indicating whether to add (true) or remove (false) from the whitelist, and 'metadata' (string memory) for associating information with the vault. It is expected to emit the 'VaultWhitelistedStatusUpdated' event."
  },
  "IBeraChef_V0.updateWhitelistedVaultMetadata": {
    "type": "external",
    "function_name": "updateWhitelistedVaultMetadata(address receiver, string memory metadata) external",
    "analysis_result": "This function is an administrative function used to update the metadata string associated with a vault address that is already on the whitelist. It is explicitly noted as callable only by the governance module account and will revert if the provided 'receiver' address is not currently whitelisted. It takes the 'receiver' address (address) and the new 'metadata' (string memory) as parameters. It is expected to emit the 'WhitelistedVaultMetadataUpdated' event."
  },
  "IBeraChef_V0.setDefaultRewardAllocation": {
    "type": "external",
    "function_name": "setDefaultRewardAllocation(RewardAllocation calldata rewardAllocation) external",
    "analysis_result": "This function is an administrative function used to set the default reward allocation that applies to validators who do not have a specific allocation set. It is explicitly noted as callable only by the governance module account. It takes a 'RewardAllocation' struct ('rewardAllocation' of type calldata) as input. Setting the default allocation is required for the 'isReady' function to return true. It is expected to emit the 'SetDefaultRewardAllocation' event."
  },
  "IBeraChef_V0.queueNewRewardAllocation": {
    "type": "external",
    "function_name": "queueNewRewardAllocation(bytes calldata valPubkey, uint64 startBlock, Weight[] calldata weights) external",
    "analysis_result": "This function allows queuing a new reward allocation configuration for a specific validator ('valPubkey'). The new allocation specifies the 'startBlock' at which it should become effective and the distribution 'weights' among various receivers. The function enforces constraints: the sum of 'percentageNumerator' in the 'weights' array must equal 10000 (representing 100%), and only addresses on the whitelisted vaults list can be used as 'receiver' addresses in the 'weights'. It also prevents overwriting an existing queued allocation for the same validator. It takes the validator's public key ('valPubkey'), the desired start block ('startBlock'), and the array of weights ('weights') as inputs. It is expected to emit the 'QueueRewardAllocation' event."
  },
  "IBeraChef_V0.activateReadyQueuedRewardAllocation": {
    "type": "external",
    "function_name": "activateReadyQueuedRewardAllocation(bytes calldata valPubkey) external",
    "analysis_result": "This function is intended to activate a validator's ('valPubkey') queued reward allocation if the conditions for activation are met. The `@dev` comment states it should be called by the distribution contract, implying it's part of the reward distribution process. Activation likely occurs when the current block number meets or exceeds the queued allocation's 'startBlock' and respects the 'rewardAllocationBlockDelay'. It takes the validator's public key ('valPubkey') as input. It is expected to emit the 'ActivateRewardAllocation' event upon successful activation."
  },
  "IRewardVault_V0.function distributor": {
    "type": "external view",
    "function_name": "function distributor() external view returns (address)",
    "analysis_result": "This function is an external view getter. It is designed to return the address currently designated as the distributor for rewards within the vault. This address is likely authorized to call functions like `notifyRewardAmount`. The implementing contract would typically read a storage variable, likely named `_distributor` or similar, to retrieve and return this address."
  },
  "IRewardVault_V0.function operator": {
    "type": "external view",
    "function_name": "function operator(address account) external view returns (address)",
    "analysis_result": "This function is an external view getter. It takes an `account` address as input and returns the address that `account` has set as their designated operator. The operator is typically allowed to claim and manage the `account`'s rewards (specifically BGT). The implementing contract would likely read a mapping storage variable, such as `_operators`, using the provided `account` address as the key to look up and return the associated operator address."
  },
  "IRewardVault_V0.function getWhitelistedTokensCount": {
    "type": "external view",
    "function_name": "function getWhitelistedTokensCount() external view returns (uint256)",
    "analysis_result": "This function is an external view getter. It returns the current number of incentive tokens that have been whitelisted by the contract owner. Whitelisted tokens are those that can be added to the vault as additional rewards for stakers beyond the primary BGT reward. The implementing contract would likely read the size or length of an internal data structure (like an array or mapping) used to store the list of whitelisted incentive tokens to determine the count."
  },
  "IRewardVault_V0.function getWhitelistedTokens": {
    "type": "external view",
    "function_name": "function getWhitelistedTokens() external view returns (address[] memory)",
    "analysis_result": "This function is an external view getter. It returns a memory array containing the addresses of all ERC20 tokens that have been whitelisted as valid incentive tokens in the vault. These tokens can be contributed by their respective managers to provide additional rewards. The implementing contract would retrieve the list of token addresses stored internally (e.g., in an array or keys of a mapping) and return them."
  },
  "IRewardVault_V0.function getTotalDelegateStaked": {
    "type": "external view",
    "function_name": "function getTotalDelegateStaked(address account) external view returns (uint256)",
    "analysis_result": "This function is an external view getter. It takes an `account` address as input and returns the total amount of staking tokens that have been staked on behalf of this `account` by one or more delegates. This aggregates the stakes from all delegates associated with the specific `account`. The implementing contract would likely read a storage variable or sum values from a mapping, potentially storing the total delegate stake per account, to return this value."
  },
  "IRewardVault_V0.function getDelegateStake": {
    "type": "external view",
    "function_name": "function getDelegateStake(address account, address delegate) external view returns (uint256)",
    "analysis_result": "This function is an external view getter. It takes an `account` address and a `delegate` address as input. It returns the specific amount of staking tokens that the given `delegate` has staked on behalf of the specified `account`. This allows querying the stake amount for a particular delegate relationship. The implementing contract would typically read a nested mapping storage variable, for example, `_delegateStakes[account][delegate]`, to retrieve the specific stake amount."
  },
  "IRewardVault_V0.function initialize": {
    "type": "external",
    "function_name": "function initialize(address _berachef, address _bgt, address _distributor, address _stakingToken) external",
    "analysis_result": "This function is an external initializer. It is intended to be called only once, likely immediately after deployment by a factory contract, to set the core dependencies and parameters of the RewardVault. It takes addresses for `_berachef`, `_bgt` (BGT token), `_distributor`, and `_stakingToken` as input. The implementing contract would store these addresses in respective storage variables. As an initializer, it must include a mechanism (like a boolean flag or relying on `address(0)` checks) to ensure it can only be called once."
  },
  "IRewardVault_V0.function setDistributor": {
    "type": "external",
    "function_name": "function setDistributor(address _rewardDistribution) external",
    "analysis_result": "This function is an external setter. It allows updating the address that is permitted to distribute rewards, likely by calling `notifyRewardAmount`. The comment indicates this function is restricted to the factory owner or a similar privileged role. It takes the new distributor address `_rewardDistribution` as input. The implementing contract would update the storage variable holding the distributor address and emit the `DistributorSet` event."
  },
  "IRewardVault_V0.function notifyRewardAmount": {
    "type": "external",
    "function_name": "function notifyRewardAmount(bytes calldata pubkey, uint256 reward) external",
    "analysis_result": "This function is an external mutative function. It is likely intended to be called by the authorized distributor to inform the vault about the amount of BGT `reward` allocated to a specific validator, identified by its `pubkey`. This function integrates with the underlying staking rewards logic (likely inherited from `IStakingRewards`) to update internal reward tracking mechanisms, ensuring that these rewards become claimable by stakers associated with that validator. The implementing contract must verify that `msg.sender` is the authorized distributor."
  },
  "IRewardVault_V0.function recoverERC20": {
    "type": "external",
    "function_name": "function recoverERC20(address tokenAddress, uint256 tokenAmount) external",
    "analysis_result": "This function is an external mutative function. It provides a safety mechanism for the contract owner (likely the factory owner) to recover arbitrary ERC20 tokens that were accidentally sent to the vault address. It takes the `tokenAddress` and the `tokenAmount` to recover as input. The implementing contract must ensure `msg.sender` is authorized and then perform an ERC20 `transfer` call from the vault's balance to a designated recovery address (e.g., the owner's address). It emits the `Recovered` event upon successful transfer. This function should be protected to prevent draining legitimate vault holdings."
  },
  "IRewardVault_V0.function setRewardsDuration": {
    "type": "external",
    "function_name": "function setRewardsDuration(uint256 _rewardsDuration) external",
    "analysis_result": "This function is an external setter. It allows the factory owner to update the duration over which the notified rewards (specifically BGT, related to `notifyRewardAmount`) are distributed. This parameter directly affects the reward rate over time in the underlying staking rewards mechanism (inherited from `IStakingRewards`). The implementing contract would update an internal storage variable representing the reward duration."
  },
  "IRewardVault_V0.function whitelistIncentiveToken": {
    "type": "external",
    "function_name": "function whitelistIncentiveToken(address token, uint256 minIncentiveRate, address manager) external",
    "analysis_result": "This function is an external mutative function. It allows the factory owner to add a new ERC20 token (`token`) to the list of approved incentive tokens. When whitelisting, a `minIncentiveRate` (minimum token amount to incentivize per BGT emission) and the initial `manager` address (authorized to call `addIncentive` for this token) are specified. It checks against `maxIncentiveTokensCount`. The implementing contract would add the token, rate, and manager to internal storage, likely a mapping, and emit the `IncentiveTokenWhitelisted` event. It must be restricted to the factory owner."
  },
  "IRewardVault_V0.function removeIncentiveToken": {
    "type": "external",
    "function_name": "function removeIncentiveToken(address token) external",
    "analysis_result": "This function is an external mutative function. It allows the factory vault manager (a privileged role, potentially different from the factory owner) to remove an existing token from the list of whitelisted incentive tokens. This prevents further `addIncentive` calls for this token. The implementing contract would remove the token's entry from internal storage and emit the `IncentiveTokenRemoved` event. Access must be restricted."
  },
  "IRewardVault_V0.function setMaxIncentiveTokensCount": {
    "type": "external",
    "function_name": "function setMaxIncentiveTokensCount(uint8 _maxIncentiveTokensCount) external",
    "analysis_result": "This function is an external setter. It allows the factory owner to update the maximum number of incentive tokens that can be simultaneously whitelisted in the vault. This caps the size of the whitelisted token list. The implementing contract would update a storage variable storing this maximum count and emit the `MaxIncentiveTokensCountUpdated` event. Access must be restricted to the factory owner."
  },
  "IRewardVault_V0.function pause": {
    "type": "external",
    "function_name": "function pause() external",
    "analysis_result": "This function is an external mutative function. It allows the factory vault pauser (a privileged role) to pause the contract, typically preventing core user actions like staking, withdrawing, claiming rewards, and potentially adding incentives. This uses a pausing mechanism (likely based on OpenZeppelin's Pausable pattern). The implementing contract would set a boolean storage variable `_paused` to true. Access must be restricted."
  },
  "IRewardVault_V0.function unpause": {
    "type": "external",
    "function_name": "function unpause() external",
    "analysis_result": "This function is an external mutative function. It allows the factory vault manager (a privileged role) to unpause the contract, re-enabling actions that were restricted by the `pause` function. The implementing contract would set a boolean storage variable `_paused` to false. Access must be restricted and separate from the pauser role."
  },
  "IRewardVault_V0.function exit": {
    "type": "external",
    "function_name": "function exit(address recipient) external",
    "analysis_result": "This function is an external mutative function. It allows `msg.sender` (the account holder themselves) to fully exit the staking vault. This action typically involves two main steps: withdrawing all their *self-staked* staking tokens and claiming all accrued BGT rewards, sending the BGT to the specified `recipient`. It's a combined 'withdraw all staking tokens and claim all rewards' action for the self-stake only. The implementing contract would interact with the underlying staking and reward logic (from `IStakingRewards`), calculate the total self-stake and rewards, perform the necessary transfers, and update or clear the account's state in storage. It cannot be called by an operator on behalf of the account."
  },
  "IRewardVault_V0.function getReward": {
    "type": "external",
    "function_name": "function getReward(address account, address recipient) external returns (uint256)",
    "analysis_result": "This function is an external mutative function. It allows either the `account` holder or their assigned `operator` (`msg.sender`) to claim the accumulated BGT rewards for the specified `account`. The claimed BGT amount is transferred to the `recipient` address. It returns the amount of BGT successfully claimed. This function specifically handles *only* the BGT rewards, not staking tokens. The implementing contract interacts with the underlying `IStakingRewards` mechanism to calculate and transfer the claimable rewards and update the account's reward state. It checks if `msg.sender` is either the `account` or their designated `operator`."
  },
  "IRewardVault_V0.function stake": {
    "type": "external",
    "function_name": "function stake(uint256 amount) external",
    "analysis_result": "This function is an external mutative function. It allows `msg.sender` to stake a specified `amount` of the vault's staking token into the vault *for themselves*. It likely requires `msg.sender` to have approved the vault contract to spend the `stakingToken` via ERC20 `approve`, as the contract will call ERC20 `transferFrom(msg.sender, address(this), amount)`. The implementing contract updates `msg.sender`'s self-staked balance in storage and integrates this stake into the underlying `IStakingRewards` logic for reward calculation. This function may be subject to pause checks."
  },
  "IRewardVault_V0.function delegateStake": {
    "type": "external",
    "function_name": "function delegateStake(address account, uint256 amount) external",
    "analysis_result": "This function is an external mutative function. It allows `msg.sender` (a delegate) to stake a specified `amount` of the staking token into the vault *on behalf of* another `account`. Similar to `stake`, it likely requires `msg.sender` to have pre-approved the vault to spend the `stakingToken` on their behalf (`transferFrom`). The implementing contract updates the specific delegate's stake amount for the given `account` in storage (e.g., `_delegateStakes[account][msg.sender]`) and potentially the total delegate stake for that account (`_totalDelegateStaked[account]`). It emits the `DelegateStaked` event. This function may be subject to pause checks."
  },
  "IRewardVault_V0.function withdraw": {
    "type": "external",
    "function_name": "function withdraw(uint256 amount) external",
    "analysis_result": "This function is an external mutative function. It allows `msg.sender` to withdraw a specified `amount` of the staking token that *they themselves* have staked from the vault. It interacts with the underlying staking logic (`IStakingRewards`) to decrease `msg.sender`'s self-staked balance in storage and transfers the corresponding `amount` of `stakingToken` back to `msg.sender`. This function only concerns the user's self-stake. This function may be subject to pause checks."
  },
  "IRewardVault_V0.function delegateWithdraw": {
    "type": "external",
    "function_name": "function delegateWithdraw(address account, uint256 amount) external",
    "analysis_result": "This function is an external mutative function. It allows `msg.sender` (a delegate) to withdraw a specified `amount` of staking tokens that *they* had previously staked on behalf of the specified `account`. It updates the specific delegate's stake amount for the given `account` in storage (`_delegateStakes[account][msg.sender]`) and potentially the total delegate stake for that account (`_totalDelegateStaked[account]`). It then transfers the corresponding `amount` of `stakingToken` back to `msg.sender`. It emits the `DelegateWithdrawn` event. This function may be subject to pause checks."
  },
  "IRewardVault_V0.function setOperator": {
    "type": "external",
    "function_name": "function setOperator(address _operator) external",
    "analysis_result": "This function is an external mutative function. It allows `msg.sender` (an account holder) to designate another address (`_operator`) as their reward operator. The designated operator will then be authorized to call `getReward` on behalf of `msg.sender`. Setting the operator to `address(0)` would remove the operator. The implementing contract updates a mapping storage variable (`_operators[msg.sender]`) to record the chosen operator and emits the `OperatorSet` event."
  },
  "IRewardVault_V0.function updateIncentiveManager": {
    "type": "external",
    "function_name": "function updateIncentiveManager(address token, address newManager) external",
    "analysis_result": "This function is an external mutative function. It allows the factory owner (or another privileged role) to change the designated manager address for a specific whitelisted incentive `token`. The `newManager` address will be the only address permitted to call `addIncentive` for that `token`. The implementing contract updates the manager address associated with the `token` in its internal storage and emits the `IncentiveManagerChanged` event. This function is restricted to authorized personnel."
  },
  "IRewardVault_V0.function addIncentive": {
    "type": "external",
    "function_name": "function addIncentive(address token, uint256 amount, uint256 incentiveRate) external",
    "analysis_result": "This function is an external mutative function. It allows the designated manager of a whitelisted `token` (`msg.sender`) to deposit a specified `amount` of that token into the vault as an incentive reward. The `incentiveRate` dictates how much of this token should be distributed per unit of BGT emission. The function verifies that `msg.sender` is the correct manager for the `token` and that the `token` is whitelisted. It requires the manager to have approved the vault to spend the `token` via ERC20 `approve`, as the vault will call `transferFrom(msg.sender, address(this), amount)`. It emits the `IncentiveAdded` event. The implementing contract updates storage to reflect the added token balance and adjusts the distribution parameters based on the `incentiveRate`. A note warns about gas costs for token transfers during distribution potentially causing failures if too high. This function may be subject to pause checks."
  },
  "Create2Deployer.deployWithCreate2": {
    "type": "internal",
    "function_name": "deployWithCreate2(uint256 salt, bytes memory initCode) returns (address addr)",
    "analysis_result": "This internal function deploys a contract using the predetermined CREATE2 factory address (0x4e59b44847b379578588920cA78FbF26c0B4956C). It takes a 'salt' (uint256) and 'initCode' (bytes) as input. The function uses inline assembly to manipulate memory, overwriting the length of 'initCode' with the 'salt', and then performs a low-level 'call' to the CREATE2 factory address. The call data is effectively 'salt' followed by the 'initCode'. It checks the success of the 'call' and reverts with a 'DeploymentFailed' error if it fails. Upon success, it extracts the deployed contract's address from the return data and restores the original length of the 'initCode' in memory. No storage variables are modified or checked. It calls an external address (_CREATE2_FACTORY)."
  },
  "Create2Deployer.getCreate2Address": [
    {
      "type": "internal pure",
      "function_name": "getCreate2Address(uint256 salt, bytes memory initCode) returns (address)",
      "analysis_result": "This internal pure function calculates the deterministic address that a contract would have if deployed using the 'deployWithCreate2' function with the given 'salt' (uint256) and 'initCode' (bytes), without actually deploying it. It computes the Keccak-256 hash of the 'initCode' and then calls the overloaded 'getCreate2Address' function with the 'salt' and this computed hash. It uses the 'salt' and 'initCode'. No storage variables are modified or checked. It calls the overloaded 'getCreate2Address' function."
    },
    {
      "type": "internal pure",
      "function_name": "getCreate2Address(uint256 salt, bytes32 initCodeHash) returns (address)",
      "analysis_result": "This internal pure function calculates the deterministic address that a contract would have if deployed using the 'deployWithCreate2' function with the given 'salt' (uint256) and 'initCodeHash' (bytes32). It uses the imported 'Create2' library's 'computeAddress' function. It takes the 'salt' (converted to bytes32), the 'initCodeHash', and the constant '_CREATE2_FACTORY' address as inputs to compute the deterministic address according to EIP-1014. It uses the 'salt', 'initCodeHash', and '_CREATE2_FACTORY'. No storage variables are modified or checked. It calls the 'computeAddress' function from the 'Create2' library."
    }
  ],
  "Create2Deployer.deployProxyWithCreate2": {
    "type": "internal",
    "function_name": "deployProxyWithCreate2(address implementation, uint256 salt) returns (address)",
    "analysis_result": "This internal function deploys an ERC1967 proxy contract using the deterministic CREATE2 factory. It takes the address of the 'implementation' contract and a 'salt' (uint256) as inputs. It first generates the specific initialization code for an ERC1967 proxy that points to the provided 'implementation' address by calling 'initCodeERC1967'. It then calls the 'deployWithCreate2' function with the given 'salt' and the generated proxy initialization code to perform the deployment. It uses the 'implementation' address and 'salt'. No storage variables are modified or checked. It calls 'initCodeERC1967' and 'deployWithCreate2'."
  },
  "Create2Deployer.getCreate2ProxyAddress": {
    "type": "internal pure",
    "function_name": "getCreate2ProxyAddress(address implementation, uint256 salt) returns (address)",
    "analysis_result": "This internal pure function calculates the deterministic address that an ERC1967 proxy contract would have if deployed using the 'deployProxyWithCreate2' function with the given 'implementation' address and 'salt', without actually deploying it. It first generates the specific initialization code for an ERC1967 proxy that points to the provided 'implementation' address by calling 'initCodeERC1967'. It then calls the overloaded 'getCreate2Address' function (the one taking bytes memory initCode) with the given 'salt' and the generated proxy initialization code. It uses the 'implementation' address and 'salt'. No storage variables are modified or checked. It calls 'initCodeERC1967' and 'getCreate2Address(uint256 salt, bytes memory initCode)'."
  },
  "Create2Deployer.initCodeERC1967": {
    "type": "internal pure",
    "function_name": "initCodeERC1967(address implementation) returns (bytes memory)",
    "analysis_result": "This internal pure function generates the initialization code needed to deploy a standard ERC1967 proxy contract configured to point to a specific 'implementation' address. It takes the 'implementation' address as input. It uses 'abi.encodePacked' to concatenate the creation code of the 'ERC1967Proxy' contract type ('type(ERC1967Proxy).creationCode') with the ABI-encoded constructor arguments for the proxy ('abi.encode(implementation, bytes(\"\"))'). The constructor arguments are the 'implementation' address and empty initialization data. It uses the 'implementation' address. No storage variables are modified or checked. It calls 'abi.encodePacked' and 'abi.encode'."
  },
  "IStakingRewards.balanceOf": {
    "type": "external view",
    "function_name": "balanceOf(address account) external view returns (uint256)",
    "analysis_result": "This function is an external view function that takes an `account` address as input. Its purpose is to retrieve the current staking balance of the specified account. It returns a `uint256` representing the amount of staked tokens held by that account."
  },
  "IStakingRewards.rewards": {
    "type": "external view",
    "function_name": "rewards(address account) external view returns (uint256)",
    "analysis_result": "This function is an external view function that takes an `account` address as input. Its purpose is to retrieve the current, uncalculated reward balance for the specified account. It returns a `uint256` representing the current reward balance."
  },
  "IStakingRewards.userRewardPerTokenPaid": {
    "type": "external view",
    "function_name": "userRewardPerTokenPaid(address account) external view returns (uint256)",
    "analysis_result": "This function is an external view function that takes an `account` address as input. Its purpose is to retrieve the value of the reward per token that was last recorded for this specific user when their staking balance or rewards were updated. It returns a `uint256` representing the user's last recorded reward per token state."
  },
  "IStakingRewards.earned": {
    "type": "external view",
    "function_name": "earned(address account) external view returns (uint256)",
    "analysis_result": "This function is an external view function that takes an `account` address as input. Its purpose is to calculate and return the total amount of reward that the specified account has earned based on their staking balance and the global reward distribution state. It returns a `uint256` representing the calculated earned reward amount for the account."
  },
  "IStakingRewards.getRewardForDuration": {
    "type": "external view",
    "function_name": "getRewardForDuration() external view returns (uint256)",
    "analysis_result": "This function is an external view function with no inputs. Its purpose is to calculate and return the total amount of reward that is distributed over the entire `rewardsDuration` period. It returns a `uint256` representing this total reward amount."
  },
  "IStakingRewards.lastTimeRewardApplicable": {
    "type": "external view",
    "function_name": "lastTimeRewardApplicable() external view returns (uint256)",
    "analysis_result": "This function is an external view function with no inputs. Its purpose is to return the timestamp up to which rewards have been calculated or are applicable. This timestamp is the minimum of the current timestamp and the `periodFinish` timestamp. It returns a `uint256` representing this calculated last applicable time."
  },
  "IStakingRewards.rewardPerToken": {
    "type": "external view",
    "function_name": "rewardPerToken() external view returns (uint256)",
    "analysis_result": "This function is an external view function with no inputs. Its purpose is to calculate and return the current global reward per unit of staked token. This value is typically calculated based on the `rewardPerTokenStored`, `lastUpdateTime`, `lastTimeRewardApplicable`, `rewardRate`, and `totalSupply`. It returns a `uint256` representing the global reward per token, usually scaled by a factor like 1e18."
  },
  "IStakingRewards.totalSupply": {
    "type": "external view",
    "function_name": "totalSupply() external view returns (uint256)",
    "analysis_result": "This function is an external view function with no inputs. Its purpose is to retrieve the total amount of staked tokens currently held in the staking vault by all users combined. It returns a `uint256` representing the total supply of staked tokens."
  },
  "IStakingRewards.periodFinish": {
    "type": "external view",
    "function_name": "periodFinish() external view returns (uint256)",
    "analysis_result": "This function is an external view function with no inputs. Its purpose is to retrieve the timestamp when the current reward distribution period is scheduled to end. After this time, new rewards will not be distributed until a new period is started. It returns a `uint256` representing the end timestamp of the current reward period."
  },
  "IStakingRewards.rewardRate": {
    "type": "external view",
    "function_name": "rewardRate() external view returns (uint256)",
    "analysis_result": "This function is an external view function with no inputs. Its purpose is to retrieve the rate at which rewards are distributed per second during the current reward period. It returns a `uint256` representing the reward rate."
  },
  "IStakingRewards.rewardsDuration": {
    "type": "external view",
    "function_name": "rewardsDuration() external view returns (uint256)",
    "analysis_result": "This function is an external view function with no inputs. Its purpose is to retrieve the total length of time, in seconds, over which a batch of rewards is intended to be distributed. It returns a `uint256` representing the duration of the reward cycle."
  },
  "IStakingRewards.lastUpdateTime": {
    "type": "external view",
    "function_name": "lastUpdateTime() external view returns (uint256)",
    "analysis_result": "This function is an external view function with no inputs. Its purpose is to retrieve the timestamp when the state affecting reward calculations (such as total supply or reward rate) was last updated. This is a key variable used in calculating accrued rewards. It returns a `uint256` representing the timestamp of the last update."
  },
  "IStakingRewards.undistributedRewards": {
    "type": "external view",
    "function_name": "undistributedRewards() external view returns (uint256)",
    "analysis_result": "This function is an external view function with no inputs. Its purpose is to retrieve the total amount of reward tokens that have been added to the contract but have not yet been distributed to users or processed in the reward calculation. It returns a `uint256` representing the amount of undistributed rewards."
  },
  "IStakingRewards.rewardPerTokenStored": {
    "type": "external view",
    "function_name": "rewardPerTokenStored() external view returns (uint256)",
    "analysis_result": "This function is an external view function with no inputs. Its purpose is to retrieve the value of the global reward per token accumulator as it was when the state was last updated (at `lastUpdateTime`). This stored value is used as a base for calculating the current `rewardPerToken`. It returns a `uint256` representing the last updated reward per token value, scaled."
  },
  "StakingRewards.__StakingRewards_init": {
    "type": "internal",
    "function_name": "__StakingRewards_init(address _stakingToken, address _rewardToken, uint256 _rewardsDuration)",
    "analysis_result": "This is an internal initializer function. It sets the addresses for the `stakeToken` and `rewardToken`, and defines the `rewardsDuration`. It is intended to be called only once during the contract's deployment and initialization, likely via a proxy pattern using the `onlyInitializing` modifier. Storage variables modified: `stakeToken`, `rewardToken`, `rewardsDuration`. No other functions are called directly within this function body."
  },
  "StakingRewards.updateReward": {
    "type": "modifier",
    "function_name": "updateReward(address account)",
    "analysis_result": "This modifier ensures that the reward state for a specific `account` (or the global state if `account` is address(0)) is updated before the decorated function's logic is executed. It calls the internal function `_updateReward(account)` to perform the update. This ensures that reward calculations (`earned`) and subsequent state changes (staking, withdrawing, claiming) are based on the most current global reward state and the account's last recorded state. It does not modify storage directly but invokes a function that does. Calls: `_updateReward(account)`."
  },
  "StakingRewards._notifyRewardAmount": {
    "type": "internal virtual",
    "function_name": "_notifyRewardAmount(uint256 reward)",
    "analysis_result": "This internal virtual function is called by authorized entities to deposit reward tokens into the contract and signal the start or continuation of a reward period. It's guarded by the `updateReward(address(0))` modifier, which updates the global reward state before processing the new reward. The input `reward` is scaled by `PRECISION`. If there is staker `totalSupply` and the current period hasn't finished, it calculates and adds the remaining potential reward from the old rate to the new incoming reward. The total new reward amount is added to `undistributedRewards`. It calls `_checkRewardSolvency` to verify the contract's reward token balance can cover `undistributedRewards`. If there is staker `totalSupply`, it calls `_setRewardRate` to calculate and set the new `rewardRate` and `periodFinish`, and updates `lastUpdateTime`. It emits the `RewardAdded` event. Storage variables modified: `rewardRate`, `undistributedRewards`, `periodFinish`, `lastUpdateTime`. Storage variables read: `totalSupply`, `periodFinish`, `rewardsDuration`. Calls: `_updateReward(address(0))`, `_computeLeftOverReward()`, `_checkRewardSolvency()`, `_setRewardRate()`. Emits: `RewardAdded`."
  },
  "StakingRewards._checkRewardSolvency": {
    "type": "internal view virtual",
    "function_name": "_checkRewardSolvency()",
    "analysis_result": "This internal view virtual function checks if the contract holds enough `rewardToken` to cover the `undistributedRewards`. It compares `undistributedRewards` (unscaled) with the contract's balance of `rewardToken`. If the contract balance is insufficient, it reverts with the `InsolventReward` error selector. This function can be overridden in inheriting contracts. Storage variables read: `undistributedRewards`. Calls: `rewardToken.balanceOf(address(this))`. Reverts: `InsolventReward`."
  },
  "StakingRewards._getReward": {
    "type": "internal virtual",
    "function_name": "_getReward(address account, address recipient)",
    "analysis_result": "This internal virtual function claims the earned rewards for a specified `account` and transfers them to a `recipient`. It is guarded by the `updateReward(account)` modifier to ensure the account's earned reward is calculated based on the latest state. It retrieves the `unclaimedReward` for the `account` from `_accountInfo`. If the reward is non-zero, it sets the account's `unclaimedReward` to zero, calls `_safeTransferRewardToken` to send the reward to the `recipient`, and emits the `RewardPaid` event. It returns the amount claimed. Storage variables modified: `_accountInfo[account].unclaimedReward`. Storage variables read: `_accountInfo[account].unclaimedReward`. Calls: `_updateReward(account)`, `_safeTransferRewardToken(recipient, reward)`. Emits: `RewardPaid`."
  },
  "StakingRewards._safeTransferRewardToken": {
    "type": "internal virtual",
    "function_name": "_safeTransferRewardToken(address to, uint256 amount)",
    "analysis_result": "This internal virtual function performs a safe transfer of `amount` of the `rewardToken` from the contract address to the `to` address using `SafeERC20`. It is marked as virtual to allow inheriting contracts to override and add custom transfer logic. Storage variables read: `rewardToken`. Calls: `rewardToken.safeTransfer(to, amount)`."
  },
  "StakingRewards._stake": {
    "type": "internal virtual",
    "function_name": "_stake(address account, uint256 amount)",
    "analysis_result": "This internal virtual function handles staking `amount` of `stakeToken` for an `account`. It first checks if the `amount` is greater than zero, reverting if not (`StakeAmountIsZero`). If `totalSupply` is zero and there are `undistributedRewards`, it calls `_setRewardRate` to start reward distribution. It then calls `_updateReward(account)` to update the account's state before changing their balance. It safely increments `totalSupply` and the account's `balance` in `_accountInfo`, checking for overflows (`TotalSupplyOverflow`). It calls `_safeTransferFromStakeToken` to transfer the `amount` from `msg.sender` to the contract. Finally, it emits the `Staked` event. Storage variables modified: `totalSupply`, `_accountInfo[account].balance`. Storage variables read: `totalSupply`, `undistributedRewards`. Calls: `_setRewardRate()`, `_updateReward(account)`, `_safeTransferFromStakeToken(msg.sender, amount)`. Emits: `Staked`. Reverts: `StakeAmountIsZero`, `TotalSupplyOverflow`."
  },
  "StakingRewards._safeTransferFromStakeToken": {
    "type": "internal virtual",
    "function_name": "_safeTransferFromStakeToken(address from, uint256 amount)",
    "analysis_result": "This internal virtual function performs a safe transfer of `amount` of the `stakeToken` from the `from` address to the contract address using `SafeERC20`. It is marked as virtual to allow inheriting contracts to override and add custom transfer logic. Storage variables read: `stakeToken`. Calls: `stakeToken.safeTransferFrom(from, address(this), amount)`."
  },
  "StakingRewards._withdraw": {
    "type": "internal virtual",
    "function_name": "_withdraw(address account, uint256 amount)",
    "analysis_result": "This internal virtual function handles withdrawing `amount` of staked `stakeToken` for an `account`. It first checks if the `amount` is greater than zero, reverting if not (`WithdrawAmountIsZero`). It calls `_updateReward(account)` to ensure the account's state is updated before changing their balance. It retrieves the account's balance, checks if it's sufficient (`InsufficientStake`), and safely decrements the account's `balance` and the global `totalSupply` in `_accountInfo`, checking for underflows. If `totalSupply` becomes zero and the period is still active, it calls `_computeLeftOverReward` and adds the result to `undistributedRewards`. It calls `_safeTransferStakeToken` to transfer the `amount` from the contract to `msg.sender`. Finally, it emits the `Withdrawn` event. Storage variables modified: `_accountInfo[account].balance`, `totalSupply`, `undistributedRewards`. Storage variables read: `_accountInfo[account].balance`, `totalSupply`, `periodFinish`. Calls: `_updateReward(account)`, `_computeLeftOverReward()`, `_safeTransferStakeToken(msg.sender, amount)`. Emits: `Withdrawn`. Reverts: `WithdrawAmountIsZero`, `InsufficientStake`."
  },
  "StakingRewards._safeTransferStakeToken": {
    "type": "internal virtual",
    "function_name": "_safeTransferStakeToken(address to, uint256 amount)",
    "analysis_result": "This internal virtual function performs a safe transfer of `amount` of the `stakeToken` from the contract address to the `to` address using `SafeERC20`. It is marked as virtual to allow inheriting contracts to override and add custom transfer logic. Storage variables read: `stakeToken`. Calls: `stakeToken.safeTransfer(to, amount)`."
  },
  "StakingRewards._setRewardRate": {
    "type": "internal virtual",
    "function_name": "_setRewardRate()",
    "analysis_result": "This internal virtual function calculates and sets the `rewardRate` and `periodFinish` for the current reward cycle based on the available `undistributedRewards` and the configured `rewardsDuration`. It calculates `rewardRate = undistributedRewards / rewardsDuration`. It sets `periodFinish` to `block.timestamp + rewardsDuration`. It subtracts the calculated total distribution for the period (`rewardRate * rewardsDuration`) from `undistributedRewards`. Storage variables modified: `rewardRate`, `periodFinish`, `undistributedRewards`. Storage variables read: `rewardsDuration`, `undistributedRewards`. No other functions called directly."
  },
  "StakingRewards._updateReward": {
    "type": "internal virtual",
    "function_name": "_updateReward(address account)",
    "analysis_result": "This internal virtual function is the core logic for updating reward states. It calculates the current global `rewardPerToken()` and stores it in `rewardPerTokenStored`. It updates `lastUpdateTime` to the result of `lastTimeRewardApplicable()`. If the `account` is not the zero address, it calculates the `earned(account)` rewards for that specific account based on the updated global state and the account's previous state, and updates the account's `unclaimedReward` and `rewardsPerTokenPaid` in `_accountInfo`. Storage variables modified: `rewardPerTokenStored`, `lastUpdateTime`, `_accountInfo[account].unclaimedReward`, `_accountInfo[account].rewardsPerTokenPaid`. Storage variables read: `rewardPerTokenStored`, `lastUpdateTime`. Calls: `rewardPerToken()`, `lastTimeRewardApplicable()`, `earned(account)`."
  },
  "StakingRewards._setRewardsDuration": {
    "type": "internal virtual",
    "function_name": "_setRewardsDuration(uint256 _rewardsDuration)",
    "analysis_result": "This internal virtual function allows updating the `rewardsDuration`. It checks if the new duration is zero, reverting if so (`RewardsDurationIsZero`). It sets the new `rewardsDuration` value and emits the `RewardsDurationUpdated` event. Note that changing `rewardsDuration` only affects the rate calculation in the *next* call to `_notifyRewardAmount`; the current `rewardRate` and `periodFinish` are not immediately adjusted. Storage variables modified: `rewardsDuration`. Reverts: `RewardsDurationIsZero`. Emits: `RewardsDurationUpdated`."
  },
  "StakingRewards._computeLeftOverReward": {
    "type": "internal view",
    "function_name": "_computeLeftOverReward()",
    "analysis_result": "This internal view function calculates the amount of reward that would be distributed at the current `rewardRate` for the remaining time until `periodFinish`. It calculates the `remainingTime` and multiplies it by `rewardRate`, returning the scaled result. This is used by `_notifyRewardAmount` and `_withdraw` to account for rewards proportional to time elapsed within the current period based on the *previous* rate. Storage variables read: `periodFinish`, `rewardRate`. No other functions called directly."
  },
  "StakingRewards.balanceOf": {
    "type": "public view virtual",
    "function_name": "balanceOf(address account)",
    "analysis_result": "This public view virtual function returns the current staked balance of `stakeToken` for a given `account`. It reads the `balance` field from the `_accountInfo` struct for that account. Storage variables read: `_accountInfo[account].balance`."
  },
  "StakingRewards.rewards": {
    "type": "public view virtual",
    "function_name": "rewards(address account)",
    "analysis_result": "This public view virtual function returns the current unclaimed reward amount for a given `account`. This value is updated by the `updateReward` modifier and cleared by `_getReward`. It reads the `unclaimedReward` field from the `_accountInfo` struct. Storage variables read: `_accountInfo[account].unclaimedReward`."
  },
  "StakingRewards.userRewardPerTokenPaid": {
    "type": "public view virtual",
    "function_name": "userRewardPerTokenPaid(address account)",
    "analysis_result": "This public view virtual function returns the `rewardsPerTokenPaid` value stored for a given `account`. This value represents the global `rewardPerTokenStored` at the last time the account's state was updated via the `updateReward` modifier. Storage variables read: `_accountInfo[account].rewardsPerTokenPaid`."
  },
  "StakingRewards.lastTimeRewardApplicable": {
    "type": "public view virtual",
    "function_name": "lastTimeRewardApplicable()",
    "analysis_result": "This public view virtual function calculates the latest timestamp up to which rewards could have accrued in the current period. It returns the minimum value between the current `block.timestamp` and the `periodFinish`. It uses `FixedPointMathLib.min` for this calculation. Storage variables read: `periodFinish`. Calls: `FixedPointMathLib.min`."
  },
  "StakingRewards.rewardPerToken": {
    "type": "public view virtual",
    "function_name": "rewardPerToken()",
    "analysis_result": "This public view virtual function calculates the current total reward per unit of staked token. It returns `rewardPerTokenStored` if `totalSupply` is zero. Otherwise, it calculates the time elapsed since `lastUpdateTime` (capped by `periodFinish` via `lastTimeRewardApplicable()`). It calculates the new reward per token delta by multiplying `rewardRate` by the elapsed time and dividing by `totalSupply` using `FixedPointMathLib.fullMulDiv` (rounding down). This delta is added to the previous `rewardPerTokenStored` to get the current value. Storage variables read: `totalSupply`, `rewardPerTokenStored`, `lastUpdateTime`, `rewardRate`. Calls: `lastTimeRewardApplicable()`, `FixedPointMathLib.fullMulDiv`."
  },
  "StakingRewards.earned": {
    "type": "public view virtual",
    "function_name": "earned(address account)",
    "analysis_result": "This public view virtual function calculates the total earned but unclaimed rewards for a specific `account`. It retrieves the account's `balance`, `unclaimedReward`, and `rewardsPerTokenPaid` from `_accountInfo`. It calculates the reward per token delta by subtracting the account's `rewardsPerTokenPaid` from the current global `rewardPerToken()`. It calculates the additional reward earned from staking the `balance` during this delta period using `FixedPointMathLib.fullMulDiv`. This additional reward is added to the account's existing `unclaimedReward`. Storage variables read: `_accountInfo[account].balance`, `_accountInfo[account].unclaimedReward`, `_accountInfo[account].rewardsPerTokenPaid`. Calls: `rewardPerToken()`, `FixedPointMathLib.fullMulDiv`."
  },
  "StakingRewards.getRewardForDuration": {
    "type": "public view virtual",
    "function_name": "getRewardForDuration()",
    "analysis_result": "This public view virtual function calculates the total amount of reward that would be distributed over one full `rewardsDuration` at the current `rewardRate`. It multiplies `rewardRate` by `rewardsDuration` and divides by `PRECISION` using `FixedPointMathLib.fullMulDiv`. Storage variables read: `rewardRate`, `rewardsDuration`. Calls: `FixedPointMathLib.fullMulDiv`."
  },
  "FactoryOwnable.__FactoryOwnable_init": {
    "type": "internal",
    "function_name": "__FactoryOwnable_init(address factoryAddr)",
    "analysis_result": "This is an internal initializer function designed to be called once during the contract's deployment or upgrade process (due to the `onlyInitializing` modifier inherited from OpenZeppelin's `Initializable`). Its purpose is to set the address of the linked factory contract. It takes a single argument, `factoryAddr`, which is the address of the factory. It uses the `_setFactory` internal function to update the `_factory` variable within the `FactoryOwnableStorage` struct, which is located at a fixed storage slot (`FactoryOwnableStorageLocation`) defined using ERC7201 pattern. This function modifies the `_factory` state variable."
  },
  "FactoryOwnable.onlyFactoryOwner": {
    "type": "modifier",
    "function_name": "onlyFactoryOwner()",
    "analysis_result": "This modifier restricts access to a function, allowing execution only if the caller (`msg.sender`) is identified as the owner of the linked factory contract. It achieves this by calling the internal helper function `_checkFactoryOwner()`. If `_checkFactoryOwner()` finds that `msg.sender` is not the factory owner, it will revert the transaction with the `OwnableUnauthorizedAccount` error. Otherwise, it allows the decorated function's code to execute (`_;`). This modifier does not directly read or write storage but relies on `_checkFactoryOwner` which in turn reads storage and interacts with the factory contract."
  },
  "FactoryOwnable.onlyFactoryVaultManager": {
    "type": "modifier",
    "function_name": "onlyFactoryVaultManager()",
    "analysis_result": "This modifier restricts access to a function, allowing execution only if the caller (`msg.sender`) has the `VAULT_MANAGER_ROLE` on the linked factory contract. It calls the internal helper function `_checkFactoryVaultManager()`. If the caller does not have the role, `_checkFactoryVaultManager()` reverts the transaction with the `OwnableUnauthorizedAccount` error. Otherwise, it allows the decorated function's code to execute (`_;`). This modifier does not directly read or write storage but relies on `_checkFactoryVaultManager` which in turn reads storage and interacts with the factory contract."
  },
  "FactoryOwnable.onlyFactoryVaultPauser": {
    "type": "modifier",
    "function_name": "onlyFactoryVaultPauser()",
    "analysis_result": "This modifier restricts access to a function, allowing execution only if the caller (`msg.sender`) has the `VAULT_PAUSER_ROLE` on the linked factory contract. It calls the internal helper function `_checkFactoryVaultPauser()`. If the caller does not have the role, `_checkFactoryVaultPauser()` reverts the transaction with the `OwnableUnauthorizedAccount` error. Otherwise, it allows the decorated function's code to execute (`_;`). This modifier does not directly read or write storage but relies on `_checkFactoryVaultPauser` which in turn reads storage and interacts with the factory contract."
  },
  "FactoryOwnable.factory": {
    "type": "public view virtual",
    "function_name": "factory() returns (address)",
    "analysis_result": "This public view function returns the address of the factory contract stored in the `_factory` state variable. It retrieves the `FactoryOwnableStorage` struct using `_getFactoryOwnableStorage()` and returns the value of its `_factory` field. It's marked `virtual` allowing inheriting contracts to override it. This function only reads the `_factory` state variable via the storage struct located at `FactoryOwnableStorageLocation`."
  },
  "FactoryOwnable.isFactoryOwner": {
    "type": "public view virtual",
    "function_name": "isFactoryOwner(address user) returns (bool)",
    "analysis_result": "This public view function checks if a given `user` address is the owner of the factory contract. It retrieves the factory address using `_getFactoryOwnableStorage()`. It then performs an external call to the factory contract (assuming it implements `AccessControlUpgradeable`) calling the `hasRole` function with the `DEFAULT_ADMIN_ROLE` (obtained via `_getAdminRole()`) and the provided `user` address. It returns `true` if the user has the role, `false` otherwise. It reads the `_factory` state variable and performs an external call."
  },
  "FactoryOwnable.isFactoryVaultManager": {
    "type": "public view virtual",
    "function_name": "isFactoryVaultManager(address user) returns (bool)",
    "analysis_result": "This public view function checks if a given `user` address has the `VAULT_MANAGER_ROLE` on the factory contract. It retrieves the factory address using `_getFactoryOwnableStorage()`. It then performs an external call to the factory contract (assuming it implements `IRewardVaultFactory` and `AccessControlUpgradeable`) calling the `hasRole` function with the `VAULT_MANAGER_ROLE` (obtained via `_getVaultManagerRole()`) and the provided `user` address. It returns `true` if the user has the role, `false` otherwise. It reads the `_factory` state variable and performs an external call."
  },
  "FactoryOwnable.isFactoryVaultPauser": {
    "type": "public view virtual",
    "function_name": "isFactoryVaultPauser(address user) returns (bool)",
    "analysis_result": "This public view function checks if a given `user` address has the `VAULT_PAUSER_ROLE` on the factory contract. It retrieves the factory address using `_getFactoryOwnableStorage()`. It then performs an external call to the factory contract (assuming it implements `IRewardVaultFactory` and `AccessControlUpgradeable`) calling the `hasRole` function with the `VAULT_PAUSER_ROLE` (obtained via `_getVaultPauserRole()`) and the provided `user` address. It returns `true` if the user has the role, `false` otherwise. It reads the `_factory` state variable and performs an external call."
  },
  "FactoryOwnable._getAdminRole": {
    "type": "internal view",
    "function_name": "_getAdminRole() returns (bytes32)",
    "analysis_result": "This internal view function retrieves the `DEFAULT_ADMIN_ROLE` bytes32 identifier from the linked factory contract. It first gets the factory address via `_getFactoryOwnableStorage()`. Then, it performs an external call to the factory contract (assuming it implements `AccessControlUpgradeable`) calling its `DEFAULT_ADMIN_ROLE()` function. This role is typically the administrative role for the factory's access control. It reads the `_factory` state variable and performs an external call."
  },
  "FactoryOwnable._getVaultManagerRole": {
    "type": "internal view",
    "function_name": "_getVaultManagerRole() returns (bytes32)",
    "analysis_result": "This internal view function retrieves the `VAULT_MANAGER_ROLE` bytes32 identifier from the linked factory contract. It first gets the factory address via `_getFactoryOwnableStorage()`. Then, it performs an external call to the factory contract (assuming it implements `IRewardVaultFactory`) calling its `VAULT_MANAGER_ROLE()` function. This role is specific to managing vaults within the factory system. It reads the `_factory` state variable and performs an external call."
  },
  "FactoryOwnable._getVaultPauserRole": {
    "type": "internal view",
    "function_name": "_getVaultPauserRole() returns (bytes32)",
    "analysis_result": "This internal view function retrieves the `VAULT_PAUSER_ROLE` bytes32 identifier from the linked factory contract. It first gets the factory address via `_getFactoryOwnableStorage()`. Then, it performs an external call to the factory contract (assuming it implements `IRewardVaultFactory`) calling its `VAULT_PAUSER_ROLE()` function. This role is specific to pausing/unpausing vaults within the factory system. It reads the `_factory` state variable and performs an external call."
  },
  "FactoryOwnable._getFactoryOwnableStorage": {
    "type": "internal pure",
    "function_name": "_getFactoryOwnableStorage() returns (struct FactoryOwnable.FactoryOwnableStorage storage $)",
    "analysis_result": "This internal pure function is a helper to get a storage pointer (`$`) to the `FactoryOwnableStorage` struct. It uses inline assembly (`assembly { $.slot := FactoryOwnableStorageLocation }`) to explicitly assign the storage slot for the struct based on the predefined `FactoryOwnableStorageLocation` constant. This is part of the ERC7201 standard for managing storage in upgradeable contracts to prevent storage collisions. It does not read or write storage itself but provides the means for other functions to access the struct's members."
  },
  "FactoryOwnable.getBGTIncentiveDistributor": {
    "type": "internal view",
    "function_name": "getBGTIncentiveDistributor() returns (address)",
    "analysis_result": "This internal view function retrieves the address of the BGTIncentiveDistributor contract from the linked factory contract. It gets the factory address via `_getFactoryOwnableStorage()`. It then performs an external call to the factory contract (assuming it implements `IRewardVaultFactory`) calling its `bgtIncentiveDistributor()` function. It returns the address returned by the factory. It reads the `_factory` state variable and performs an external call."
  },
  "FactoryOwnable._setFactory": {
    "type": "internal",
    "function_name": "_setFactory(address factoryAddr)",
    "analysis_result": "This internal function sets the address of the linked factory contract in storage. It takes `factoryAddr` as input. It retrieves the storage pointer to the `FactoryOwnableStorage` struct using `_getFactoryOwnableStorage()` and assigns the input `factoryAddr` to the `$._factory` field. This function modifies the `_factory` state variable via the storage struct at `FactoryOwnableStorageLocation`."
  },
  "FactoryOwnable._checkFactoryOwner": {
    "type": "internal view",
    "function_name": "_checkFactoryOwner()",
    "analysis_result": "This internal view function checks if the current message sender (`msg.sender`) is the factory owner. It calls the `isFactoryOwner` function, passing `msg.sender`. If `isFactoryOwner` returns `false`, it reverts the transaction using the custom error `OwnableUnauthorizedAccount` and includes `msg.sender` as an argument to the error. This function reads the `_factory` state variable indirectly via `isFactoryOwner` and makes external calls implicitly via `isFactoryOwner`. It is called by the `onlyFactoryOwner` modifier."
  },
  "FactoryOwnable._checkFactoryVaultManager": {
    "type": "internal view",
    "function_name": "_checkFactoryVaultManager()",
    "analysis_result": "This internal view function checks if the current message sender (`msg.sender`) has the `VAULT_MANAGER_ROLE` on the factory contract. It calls the `isFactoryVaultManager` function, passing `msg.sender`. If `isFactoryVaultManager` returns `false`, it reverts the transaction using the custom error `OwnableUnauthorizedAccount` and includes `msg.sender`. This function reads the `_factory` state variable indirectly via `isFactoryVaultManager` and makes external calls implicitly via `isFactoryVaultManager`. It is called by the `onlyFactoryVaultManager` modifier."
  },
  "FactoryOwnable._checkFactoryVaultPauser": {
    "type": "internal view",
    "function_name": "_checkFactoryVaultPauser()",
    "analysis_result": "This internal view function checks if the current message sender (`msg.sender`) has the `VAULT_PAUSER_ROLE` on the factory contract. It calls the `isFactoryVaultPauser` function, passing `msg.sender`. If `isFactoryVaultPauser` returns `false`, it reverts the transaction using the custom error `OwnableUnauthorizedAccount` and includes `msg.sender`. This function reads the `_factory` state variable indirectly via `isFactoryVaultPauser` and makes external calls implicitly via `isFactoryVaultPauser`. It is called by the `onlyFactoryVaultPauser` modifier."
  },
  "BeraChef_V1.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor for the `BeraChef_V1` contract. It is marked with `_disableInitializers()` from the OpenZeppelin `UUPSUpgradeable` pattern. This prevents the `initialize` function from being called directly during contract deployment and ensures that the contract can only be initialized via the proxy pattern. It does not take any arguments and does not modify any storage variables directly."
  },
  "BeraChef_V1.initialize": {
    "type": "external",
    "function_name": "initialize(address _distributor, address _factory, address _governance, address _beaconDepositContract, uint8 _maxNumWeightsPerRewardAllocation)",
    "analysis_result": "This is the initializer function, intended to be called once via a proxy contract as part of the upgradeable contract pattern. It is guarded by the `initializer` modifier. It initializes the `OwnableUpgradeable` (setting the owner to `_governance`) and `UUPSUpgradeable` base contracts. It sets the `distributor`, `factory`, and `beaconDepositContract` storage variables based on the input parameters. It checks if `_maxNumWeightsPerRewardAllocation` is zero and reverts if it is, using the `MaxNumWeightsPerRewardAllocationIsZero` selector. It then sets the `maxNumWeightsPerRewardAllocation` storage variable. It emits the `MaxNumWeightsPerRewardAllocationSet` event. It uses the `__Ownable_init` and `__UUPSUpgradeable_init` internal initializer functions from the inherited OpenZeppelin contracts."
  },
  "BeraChef_V1._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This is an internal function overriding the `UUPSUpgradeable._authorizeUpgrade` function. It is called by the UUPS proxy mechanism to authorize an upgrade. This specific implementation simply requires that the caller is the contract owner, as enforced by the `onlyOwner` modifier. It takes the address of the new implementation as input but does not use it directly in its logic besides passing OpenZeppelin's check. It does not modify storage variables."
  },
  "BeraChef_V1.onlyDistributor": {
    "type": "modifier",
    "function_name": "onlyDistributor()",
    "analysis_result": "This is a modifier that restricts access to the function it decorates to only the address stored in the `distributor` storage variable. It checks if `msg.sender` is equal to `distributor` and reverts with the `NotDistributor` selector if not. It does not take arguments and does not modify storage."
  },
  "BeraChef_V1.onlyOperator": {
    "type": "modifier",
    "function_name": "onlyOperator(bytes calldata valPubkey)",
    "analysis_result": "This is a modifier that restricts access to the function it decorates to only the operator address associated with a given validator public key. It calls the `beaconDepositContract.getOperator(valPubkey)` external view function to get the operator address. It checks if `msg.sender` is equal to the returned operator address and reverts with the `NotOperator` selector if not. It takes the validator public key (`valPubkey`) as an argument and does not modify storage."
  },
  "BeraChef_V1.setMaxNumWeightsPerRewardAllocation": {
    "type": "external",
    "function_name": "setMaxNumWeightsPerRewardAllocation(uint8 _maxNumWeightsPerRewardAllocation)",
    "analysis_result": "This function allows the contract owner to set the maximum number of weights allowed per reward allocation. It is restricted to the contract owner by the `onlyOwner` modifier. It checks if `_maxNumWeightsPerRewardAllocation` is zero and reverts using `MaxNumWeightsPerRewardAllocationIsZero` selector if it is. It then checks if the new limit (`_maxNumWeightsPerRewardAllocation`) is less than the current number of weights in the `defaultRewardAllocation.weights` array. If it is, it means changing the limit would invalidate the existing default allocation, so it reverts using the `InvalidateDefaultRewardAllocation` selector. If checks pass, it updates the `maxNumWeightsPerRewardAllocation` storage variable and emits the `MaxNumWeightsPerRewardAllocationSet` event."
  },
  "BeraChef_V1.setRewardAllocationBlockDelay": {
    "type": "external",
    "function_name": "setRewardAllocationBlockDelay(uint64 _rewardAllocationBlockDelay)",
    "analysis_result": "This function allows the contract owner to set the block delay before a queued reward allocation becomes active. It is restricted to the contract owner by the `onlyOwner` modifier. It checks if `_rewardAllocationBlockDelay` is greater than the constant `MAX_REWARD_ALLOCATION_BLOCK_DELAY` (1_315_000) and reverts using `RewardAllocationBlockDelayTooLarge` selector if it is. If the check passes, it updates the `rewardAllocationBlockDelay` storage variable and emits the `RewardAllocationBlockDelaySet` event."
  },
  "BeraChef_V1.setVaultWhitelistedStatus": {
    "type": "external",
    "function_name": "setVaultWhitelistedStatus(address receiver, bool isWhitelisted, string memory metadata)",
    "analysis_result": "This function allows the contract owner to whitelist or unwhitelist a vault address. It is restricted to the contract owner by the `onlyOwner` modifier. It first verifies that the provided `receiver` address corresponds to a valid vault registered in the `factory` contract by calling `RewardVault(receiver).stakeToken()` to get the stake token and then `IRewardVaultFactory(factory).getVault(stakeToken)` to get the factory's registered vault for that token. It reverts using `NotFactoryVault` selector if the provided `receiver` is not the same as the vault returned by the factory. It updates the `isWhitelistedVault` mapping for the given `receiver`. If the vault is being unwhitelisted (`isWhitelisted` is false), it checks if the current `defaultRewardAllocation` is still valid (meaning all its weights point to currently whitelisted vaults) by calling the internal `_checkIfStillValid` function. If unwhitelisting this vault invalidates the default allocation, it reverts using `InvalidRewardAllocationWeights` selector. Finally, it emits the `VaultWhitelistedStatusUpdated` event with the receiver address, new status, and metadata."
  },
  "BeraChef_V1.updateWhitelistedVaultMetadata": {
    "type": "external",
    "function_name": "updateWhitelistedVaultMetadata(address vault, string memory metadata)",
    "analysis_result": "This function allows the contract owner to update the metadata for an already whitelisted vault. It is restricted to the contract owner by the `onlyOwner` modifier. It checks if the provided `vault` address is currently whitelisted by reading the `isWhitelistedVault` mapping. If it's not whitelisted, it reverts using `NotWhitelistedVault` selector. If whitelisted, it emits the `WhitelistedVaultMetadataUpdated` event with the vault address and the new metadata. It does not modify any storage variables, only emits an event."
  },
  "BeraChef_V1.setDefaultRewardAllocation": {
    "type": "external",
    "function_name": "setDefaultRewardAllocation(RewardAllocation calldata ra)",
    "analysis_result": "This function allows the contract owner to set the default reward allocation. It is restricted to the contract owner by the `onlyOwner` modifier. It first calls the internal `_validateWeights` function to ensure the provided `ra.weights` are valid (total weight is 100%, receivers are whitelisted vaults, and number of weights is within the `maxNumWeightsPerRewardAllocation` limit). If validation fails, it reverts. If validation passes, it updates the `defaultRewardAllocation` storage variable with the provided `ra` and emits the `SetDefaultRewardAllocation` event."
  },
  "BeraChef_V1.setCommissionChangeDelay": {
    "type": "external",
    "function_name": "setCommissionChangeDelay(uint64 _commissionChangeDelay)",
    "analysis_result": "This function allows the contract owner to set the minimum delay in blocks before a validator's queued commission rate change can be activated. It is restricted to the contract owner by the `onlyOwner` modifier. It checks if `_commissionChangeDelay` is zero or greater than the constant `MAX_COMMISSION_CHANGE_DELAY` (2 * 8191) and reverts using `InvalidCommissionChangeDelay` selector if either condition is true. If the check passes, it updates the `commissionChangeDelay` storage variable and emits the `CommissionChangeDelaySet` event."
  },
  "BeraChef_V1.queueNewRewardAllocation": {
    "type": "external",
    "function_name": "queueNewRewardAllocation(bytes calldata valPubkey, uint64 startBlock, Weight[] calldata weights)",
    "analysis_result": "This function allows a validator's operator to queue a new reward allocation for that validator. It is restricted to the validator's operator by the `onlyOperator(valPubkey)` modifier, which calls `beaconDepositContract.getOperator(valPubkey)`. It checks if the requested `startBlock` is strictly greater than the current block number plus the `rewardAllocationBlockDelay`. If not, it reverts using `InvalidStartBlock` selector. It checks if there is already a queued reward allocation for the given `valPubkey` by examining `queuedRewardAllocations[valPubkey].startBlock`. If `startBlock` is greater than 0, it means one is already queued, and it reverts using `RewardAllocationAlreadyQueued` selector. It calls the internal `_validateWeights` function to ensure the provided `weights` are valid. If validation passes, it updates the `queuedRewardAllocations` mapping for `valPubkey`, setting the `startBlock` and copying the `weights` array. It emits the `QueueRewardAllocation` event."
  },
  "BeraChef_V1.queueValCommission": {
    "type": "external",
    "function_name": "queueValCommission(bytes calldata valPubkey, uint96 commissionRate)",
    "analysis_result": "This function allows a validator's operator to queue a new commission rate for that validator. It is restricted to the validator's operator by the `onlyOperator(valPubkey)` modifier, which calls `beaconDepositContract.getOperator(valPubkey)`. It checks if the provided `commissionRate` is greater than `ONE_HUNDRED_PERCENT` (1e4) and reverts using `InvalidCommissionValue` selector if it is. It checks if there is already a queued commission change for the given `valPubkey` by examining `valQueuedCommission[valPubkey].blockNumberLast`. If `blockNumberLast` is greater than 0, it means one is already queued, and it reverts using `CommissionChangeAlreadyQueued` selector. If checks pass, it updates the `valQueuedCommission` mapping for `valPubkey`, setting `blockNumberLast` to the current block number and `commissionRate` to the provided value. It emits the `QueuedValCommission` event."
  },
  "BeraChef_V1.activateQueuedValCommission": {
    "type": "external",
    "function_name": "activateQueuedValCommission(bytes calldata valPubkey)",
    "analysis_result": "This function allows anyone to activate a queued commission rate change for a validator if the required block delay has passed. It takes the validator's public key (`valPubkey`) as input. It retrieves the queued commission change details (`blockNumberLast`, `commissionRate`) from the `valQueuedCommission` mapping. It calculates the activation block number (`activationBlock`) by adding `commissionChangeDelay` to `blockNumberLast`. It checks if `blockNumberLast` is zero (meaning no commission change is queued) or if the current block number is less than the `activationBlock`. If either condition is true, it reverts using `CommissionNotQueuedOrDelayNotPassed` selector. If the activation conditions are met, it calls the internal `_getOperatorCommission` function to get the validator's *current* active commission rate (`oldCommission`). It then updates the `valCommission` mapping for `valPubkey` with the new `commissionRate` and sets the `activationBlock` to the calculated value. It emits the `ValCommissionSet` event with the validator public key, the old commission, and the new commission. Finally, it deletes the queued commission entry from `valQueuedCommission`."
  },
  "BeraChef_V1.activateReadyQueuedRewardAllocation": {
    "type": "external",
    "function_name": "activateReadyQueuedRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This function allows the `distributor` to activate a queued reward allocation for a validator if it is ready (i.e., the start block has been reached or passed). It is restricted to the `distributor` address by the `onlyDistributor` modifier. It first checks if the queued reward allocation for `valPubkey` is ready by calling the public `isQueuedRewardAllocationReady(valPubkey, block.number)` function. If it's not ready, the function simply returns without doing anything. If it is ready, it retrieves the queued reward allocation (`qra`) from `queuedRewardAllocations[valPubkey]`, copies it to the `activeRewardAllocations` mapping for `valPubkey`, emits the `ActivateRewardAllocation` event with the validator public key, start block, and weights, and then deletes the queued entry from `queuedRewardAllocations`."
  },
  "BeraChef_V1.getActiveRewardAllocation": {
    "type": "external",
    "function_name": "getActiveRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This is a public view function that returns the active reward allocation for a given validator. It takes the validator's public key (`valPubkey`) as input. It first retrieves the reward allocation stored in `activeRewardAllocations[valPubkey]`. It checks if this allocation has a non-zero `startBlock` and if its weights are still valid (all receivers are whitelisted) by calling the internal `_checkIfStillValid` function. If both conditions are true, it returns this active reward allocation. If not (either no active allocation is set, or the set allocation contains unwhitelisted vaults due to later changes), it returns the `defaultRewardAllocation` storage variable instead. It does not modify storage."
  },
  "BeraChef_V1.getQueuedRewardAllocation": {
    "type": "external",
    "function_name": "getQueuedRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This is a public view function that returns the queued reward allocation for a given validator. It takes the validator's public key (`valPubkey`) as input. It simply returns the `RewardAllocation` struct stored in the `queuedRewardAllocations[valPubkey]` mapping. It does not modify storage."
  },
  "BeraChef_V1.getSetActiveRewardAllocation": {
    "type": "external",
    "function_name": "getSetActiveRewardAllocation(bytes calldata valPubkey)",
    "analysis_result": "This is a public view function that returns the *currently set* active reward allocation for a validator, regardless of whether its weights are still valid. It takes the validator's public key (`valPubkey`) as input. It directly returns the `RewardAllocation` struct stored in the `activeRewardAllocations[valPubkey]` mapping. This differs from `getActiveRewardAllocation` which performs validity checks and might return the default. It does not modify storage."
  },
  "BeraChef_V1.getDefaultRewardAllocation": {
    "type": "external",
    "function_name": "getDefaultRewardAllocation()",
    "analysis_result": "This is a public view function that returns the default reward allocation. It returns the `RewardAllocation` struct stored in the `defaultRewardAllocation` storage variable. It does not modify storage."
  },
  "BeraChef_V1.isQueuedRewardAllocationReady": {
    "type": "public",
    "function_name": "isQueuedRewardAllocationReady(bytes calldata valPubkey, uint256 blockNumber)",
    "analysis_result": "This is a public view function that checks if a queued reward allocation for a validator is ready to be activated based on a given block number. It takes the validator's public key (`valPubkey`) and a `blockNumber` as input. It retrieves the `startBlock` of the queued allocation from `queuedRewardAllocations[valPubkey]`. It returns `true` if the `startBlock` is non-zero and is less than or equal to the provided `blockNumber`. Otherwise, it returns `false`. It does not modify storage."
  },
  "BeraChef_V1.isReady": {
    "type": "external",
    "function_name": "isReady()",
    "analysis_result": "This is a public view function that indicates whether the contract is ready for use. It checks if the `defaultRewardAllocation` has been set by checking if its `weights` array has a length greater than 0. It returns `true` if the default allocation is set, and `false` otherwise. It does not modify storage."
  },
  "BeraChef_V1.getValCommissionOnIncentiveTokens": {
    "type": "external",
    "function_name": "getValCommissionOnIncentiveTokens(bytes calldata valPubkey)",
    "analysis_result": "This is a public view function that returns the active commission rate for a validator on incentive tokens. It takes the validator's public key (`valPubkey`) as input. It calls the internal `_getOperatorCommission` function to determine and return the appropriate commission rate (either the set rate from `valCommission` or the `DEFAULT_COMMISSION_RATE` if not set). It does not modify storage."
  },
  "BeraChef_V1.getValQueuedCommissionOnIncentiveTokens": {
    "type": "external",
    "function_name": "getValQueuedCommissionOnIncentiveTokens(bytes calldata valPubkey)",
    "analysis_result": "This is a public view function that returns the queued commission rate change details for a validator. It takes the validator's public key (`valPubkey`) as input. It returns the `QueuedCommissionRateChange` struct stored in the `valQueuedCommission[valPubkey]` mapping. It does not modify storage."
  },
  "BeraChef_V1.getValidatorIncentiveTokenShare": {
    "type": "external",
    "function_name": "getValidatorIncentiveTokenShare(bytes calldata valPubkey, uint256 incentiveTokenAmount)",
    "analysis_result": "This is a public view function that calculates the validator's share of a given amount of incentive tokens based on their commission rate. It takes the validator's public key (`valPubkey`) and the total `incentiveTokenAmount` as input. It calls the internal `_getOperatorCommission` function to get the validator's active commission rate. It then calculates the operator's share as `(incentiveTokenAmount * operatorCommission) / ONE_HUNDRED_PERCENT`. It returns the calculated operator share amount. It does not modify storage."
  },
  "BeraChef_V1._validateWeights": {
    "type": "internal",
    "function_name": "_validateWeights(Weight[] calldata weights)",
    "analysis_result": "This is an internal view function used to validate a given array of `Weight` structs intended for a reward allocation. It takes the `weights` array as input. It first checks if the length of the `weights` array exceeds the `maxNumWeightsPerRewardAllocation` and reverts using `TooManyWeights` selector if it does. It then iterates through the `weights` array, ensuring that each `percentageNumerator` is non-zero (reverting with `ZeroPercentageWeight` if zero) and that the `receiver` address for each weight is currently whitelisted (checking `isWhitelistedVault` mapping and reverting with `NotWhitelistedVault` if not whitelisted). While iterating, it sums up the `percentageNumerator` values. Finally, it checks if the total sum of `percentageNumerator` is equal to `ONE_HUNDRED_PERCENT` (1e4) and reverts using `InvalidRewardAllocationWeights` selector if it is not. It does not modify storage."
  },
  "BeraChef_V1._checkIfStillValid": {
    "type": "internal",
    "function_name": "_checkIfStillValid(Weight[] memory weights)",
    "analysis_result": "This is an internal view function used to check if an existing reward allocation's weights are still considered valid based on the *current* contract state (specifically, the `maxNumWeightsPerRewardAllocation` limit and the `isWhitelistedVault` mapping). It takes a `weights` array in memory as input. It first checks if the length of the `weights` array is greater than the current `maxNumWeightsPerRewardAllocation`. If it is, the allocation is considered invalid, and it returns `false`. If the length check passes, it iterates through the `weights` array. For each weight, it checks if the `receiver` address is currently whitelisted by reading the `isWhitelistedVault` mapping. If it finds any receiver that is *not* whitelisted, it immediately returns `false`. If the loop completes without finding any non-whitelisted receivers, it returns `true`. It does not modify storage."
  },
  "BeraChef_V1._getOperatorCommission": {
    "type": "internal",
    "function_name": "_getOperatorCommission(bytes calldata valPubkey)",
    "analysis_result": "This is an internal view function that retrieves the active commission rate for a validator. It takes the validator's public key (`valPubkey`) as input. It reads the `CommissionRate` struct from the `valCommission[valPubkey]` mapping. If the `activationBlock` in this struct is 0, it means no specific commission rate has ever been set for this validator, so it returns the constant `DEFAULT_COMMISSION_RATE` (0.05e4). Otherwise, it returns the `commissionRate` stored in the struct. It does not modify storage."
  },
  "RewardVault_V1.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "The constructor for the RewardVault_V1 contract. It is marked with `_disableInitializers()` which is a standard pattern in OpenZeppelin Upgradeable contracts to prevent the `initializer` function from being called directly via the constructor, ensuring it can only be called once via the upgrade proxy's `initialize` function. It does not perform any other setup logic itself."
  },
  "RewardVault_V1.initialize": {
    "type": "external",
    "function_name": "initialize(address _beaconDepositContract, address _bgt, address _distributor, address _stakingToken)",
    "analysis_result": "This is the initializer function for the upgradeable contract, called once after deployment via the proxy. It initializes inherited contracts: `__FactoryOwnable_init` with `msg.sender` (the deployer/factory), `__Pausable_init`, and `__ReentrancyGuard_init`. It also initializes `__StakingRewards_init` with the provided `_stakingToken`, `_bgt` (reward token), and a default rewards duration of 7 days. It sets the `maxIncentiveTokensCount` to 2. It sets the `distributor` address, checking for a zero address. It sets the `beaconDepositContract` address by casting the input address to `IBeaconDeposit`. It emits the `DistributorSet` and `MaxIncentiveTokensCountUpdated` events. State variables modified: `owner` (via `__FactoryOwnable_init`), `_paused` (via `__Pausable_init`), `_status` (via `__ReentrancyGuard_init`), `stakeToken`, `rewardToken`, `rewardsDuration`, `maxIncentiveTokensCount`, `distributor`, `beaconDepositContract`. Errors: Reverts if `_distributor` is the zero address (`ZeroAddress`)."
  },
  "RewardVault_V1.onlyDistributor": {
    "type": "modifier",
    "function_name": "onlyDistributor()",
    "analysis_result": "This modifier restricts access to a function, allowing only the address stored in the `distributor` state variable to call it. It checks `msg.sender` against `distributor`. Errors: Reverts with `NotDistributor` if `msg.sender` is not the distributor."
  },
  "RewardVault_V1.onlyOperatorOrUser": {
    "type": "modifier",
    "function_name": "onlyOperatorOrUser(address account)",
    "analysis_result": "This modifier restricts access to a function, allowing either the `account` itself or the address stored as the operator for that `account` in the `_operators` mapping (`_operators[account]`) to call it. It checks `msg.sender` against both `account` and `_operators[account]`. Errors: Reverts with `NotOperator` if `msg.sender` is neither the account nor its designated operator."
  },
  "RewardVault_V1.checkSelfStakedBalance": {
    "type": "modifier",
    "function_name": "checkSelfStakedBalance(address account, uint256 amount)",
    "analysis_result": "This modifier checks if the `account` has a sufficient amount of self-staked balance (total staked minus delegated stake) to cover the specified `amount`. It calls the internal function `_checkSelfStakedBalance` with the provided account and amount. It does not perform the check directly but delegates it to the internal helper."
  },
  "RewardVault_V1.onlyWhitelistedToken": {
    "type": "modifier",
    "function_name": "onlyWhitelistedToken(address token)",
    "analysis_result": "This modifier restricts access to a function, allowing it only if the provided `token` address is present in the `incentives` mapping and its `minIncentiveRate` is non-zero, indicating it is a whitelisted incentive token. Errors: Reverts with `TokenNotWhitelisted` if the token is not whitelisted (checked by `incentives[token].minIncentiveRate == 0`)."
  },
  "RewardVault_V1.setDistributor": {
    "type": "external",
    "function_name": "setDistributor(address _rewardDistribution)",
    "analysis_result": "Allows the `factoryOwner` to update the address of the `distributor` contract. This function is guarded by the `onlyFactoryOwner` modifier. It checks if the new distributor address is not the zero address. Updates the `distributor` state variable and emits the `DistributorSet` event. State variables modified: `distributor`. Errors: Reverts if `_rewardDistribution` is the zero address (`ZeroAddress`). Modifiers: `onlyFactoryOwner`."
  },
  "RewardVault_V1.notifyRewardAmount": {
    "type": "external",
    "function_name": "notifyRewardAmount(bytes calldata pubkey, uint256 reward)",
    "analysis_result": "This function is called by the `distributor` to signal that new rewards (BGT) are available for distribution. It is guarded by the `onlyDistributor` modifier. It first calls the inherited `_notifyRewardAmount(reward)` from `StakingRewards` to update the reward rate and state for the main BGT reward. Then, it calls the internal function `_processIncentives(pubkey, reward)` to handle the distribution of any whitelisted incentive tokens based on the BGT reward amount and the validator's pubkey. State variables modified: `rewardPerTokenStored`, `lastUpdateTime`, `rewardRate`, `lastTimeRewardApplicable` (via `_notifyRewardAmount`). Modifiers: `onlyDistributor`."
  },
  "RewardVault_V1.recoverERC20": {
    "type": "external",
    "function_name": "recoverERC20(address tokenAddress, uint256 tokenAmount)",
    "analysis_result": "Allows the `factoryOwner` to recover ERC20 tokens accidentally sent to the contract address, provided they are not the `stakeToken` or a whitelisted incentive token with a non-zero `minIncentiveRate`. It uses `SafeERC20.safeTransfer` to send the `tokenAmount` of `tokenAddress` to `msg.sender`. Emits the `Recovered` event. State variables checked: `stakeToken`, `incentives[tokenAddress].minIncentiveRate`. External calls: `IERC20(tokenAddress).safeTransfer`. Modifiers: `onlyFactoryOwner`. Errors: Reverts with `CannotRecoverStakingToken` if the token is the stake token. Reverts with `CannotRecoverIncentiveToken` if the token is a whitelisted incentive token with `minIncentiveRate != 0`."
  },
  "RewardVault_V1.setRewardsDuration": {
    "type": "external",
    "function_name": "setRewardsDuration(uint256 _rewardsDuration)",
    "analysis_result": "Allows the `factoryOwner` to update the `rewardsDuration` for the main BGT reward. It calls the inherited `_setRewardsDuration(_rewardsDuration)` from `StakingRewards`. Modifiers: `onlyFactoryOwner`."
  },
  "RewardVault_V1.whitelistIncentiveToken": {
    "type": "external",
    "function_name": "whitelistIncentiveToken(address token, uint256 minIncentiveRate, address manager)",
    "analysis_result": "Allows the `factoryOwner` to add a new token to the list of whitelisted incentive tokens. It validates `minIncentiveRate` (must be > 0 and <= `MAX_INCENTIVE_RATE`). It validates `token` and `manager` addresses (must not be zero address). It checks if the maximum number of whitelisted tokens (`maxIncentiveTokensCount`) has been reached or if the token is already whitelisted (by checking `incentives[token].minIncentiveRate`). If validation passes and the token is not whitelisted and the limit is not reached, it adds the token to the `whitelistedTokens` array, sets its initial `incentiveRate` and `minIncentiveRate` to the provided `minIncentiveRate`, and sets the `manager` in the `incentives` mapping. Emits the `IncentiveTokenWhitelisted` event. State variables modified: `incentives`, `whitelistedTokens`. State variables checked: `maxIncentiveTokensCount`, `incentives[token].minIncentiveRate`. Modifiers: `onlyFactoryOwner`. Errors: Reverts with `MinIncentiveRateIsZero` if `minIncentiveRate` is 0. Reverts with `IncentiveRateTooHigh` if `minIncentiveRate` exceeds `MAX_INCENTIVE_RATE`. Reverts with `ZeroAddress` if `token` or `manager` is the zero address. Reverts with `TokenAlreadyWhitelistedOrLimitReached` if `whitelistedTokens.length == maxIncentiveTokensCount` or `incentives[token].minIncentiveRate != 0`."
  },
  "RewardVault_V1.removeIncentiveToken": {
    "type": "external",
    "function_name": "removeIncentiveToken(address token)",
    "analysis_result": "Allows the `factoryVaultManager` to remove a token from the list of whitelisted incentive tokens. It is guarded by `onlyFactoryVaultManager` and `onlyWhitelistedToken` (ensuring the token exists in the list). It deletes the entry for the `token` from the `incentives` mapping. It then calls the internal function `_deleteWhitelistedTokenFromList(token)` to remove the token from the `whitelistedTokens` array. Emits the `IncentiveTokenRemoved` event. State variables modified: `incentives`, `whitelistedTokens` (via `_deleteWhitelistedTokenFromList`). Modifiers: `onlyFactoryVaultManager`, `onlyWhitelistedToken`."
  },
  "RewardVault_V1.updateIncentiveManager": {
    "type": "external",
    "function_name": "updateIncentiveManager(address token, address newManager)",
    "analysis_result": "Allows the `factoryOwner` to update the manager address for a whitelisted incentive token. It is guarded by `onlyFactoryOwner` and `onlyWhitelistedToken`. It checks if the `newManager` address is not the zero address. It updates the `manager` field for the `token` in the `incentives` mapping. Emits the `IncentiveManagerChanged` event. State variables modified: `incentives[token].manager`. Modifiers: `onlyFactoryOwner`, `onlyWhitelistedToken`. Errors: Reverts with `ZeroAddress` if `newManager` is the zero address."
  },
  "RewardVault_V1.setMaxIncentiveTokensCount": {
    "type": "external",
    "function_name": "setMaxIncentiveTokensCount(uint8 _maxIncentiveTokensCount)",
    "analysis_result": "Allows the `factoryOwner` to update the maximum number of incentive tokens that can be whitelisted. It is guarded by `onlyFactoryOwner`. It checks if the new maximum count is less than the current number of whitelisted tokens (`whitelistedTokens.length`). Updates the `maxIncentiveTokensCount` state variable. Emits the `MaxIncentiveTokensCountUpdated` event. State variables modified: `maxIncentiveTokensCount`. State variables checked: `whitelistedTokens.length`. Modifiers: `onlyFactoryOwner`. Errors: Reverts with `InvalidMaxIncentiveTokensCount` if `_maxIncentiveTokensCount` is less than the current number of whitelisted tokens."
  },
  "RewardVault_V1.pause": {
    "type": "external",
    "function_name": "pause()",
    "analysis_result": "Allows the `factoryVaultPauser` to pause the contract, preventing most operations that modify state (like stake, withdraw, getReward, exit, addIncentive). It calls the inherited `_pause()` from `PausableUpgradeable`. Modifiers: `onlyFactoryVaultPauser`."
  },
  "RewardVault_V1.unpause": {
    "type": "external",
    "function_name": "unpause()",
    "analysis_result": "Allows the `factoryVaultManager` to unpause the contract, re-enabling operations prevented by pausing. It calls the inherited `_unpause()` from `PausableUpgradeable`. Modifiers: `onlyFactoryVaultManager`."
  },
  "RewardVault_V1.operator": {
    "type": "external",
    "function_name": "operator(address account)",
    "analysis_result": "A getter function that returns the operator address set for a given `account` from the `_operators` mapping. This is a view function, meaning it does not modify state. State variables checked: `_operators[account]`."
  },
  "RewardVault_V1.getWhitelistedTokensCount": {
    "type": "external",
    "function_name": "getWhitelistedTokensCount()",
    "analysis_result": "A getter function that returns the current number of whitelisted incentive tokens, which is the length of the `whitelistedTokens` array. This is a view function. State variables checked: `whitelistedTokens.length`."
  },
  "RewardVault_V1.getWhitelistedTokens": {
    "type": "public",
    "function_name": "getWhitelistedTokens()",
    "analysis_result": "A getter function that returns the array of all whitelisted incentive token addresses. This is a view function. State variables checked: `whitelistedTokens`."
  },
  "RewardVault_V1.getTotalDelegateStaked": {
    "type": "external",
    "function_name": "getTotalDelegateStaked(address account)",
    "analysis_result": "A getter function that returns the total amount of staking tokens delegated to a given `account` from the `_delegateStake` mapping. This is a view function. State variables checked: `_delegateStake[account].delegateTotalStaked`."
  },
  "RewardVault_V1.getDelegateStake": {
    "type": "external",
    "function_name": "getDelegateStake(address account, address delegate)",
    "analysis_result": "A getter function that returns the amount of staking tokens staked by a specific `delegate` on behalf of a given `account`, from the nested mapping within `_delegateStake`. This is a view function. State variables checked: `_delegateStake[account].stakedByDelegate[delegate]`."
  },
  "RewardVault_V1.stake": {
    "type": "external",
    "function_name": "stake(uint256 amount)",
    "analysis_result": "Allows `msg.sender` to stake `amount` of the staking token. It is guarded by `nonReentrant` and `whenNotPaused`. It calls the inherited `_stake(msg.sender, amount)` from `StakingRewards` to handle the core staking logic (transferring tokens to the vault and updating account balance and total supply). State variables modified: `_accountInfo`, `_totalSupply` (via `_stake`). Modifiers: `nonReentrant`, `whenNotPaused`."
  },
  "RewardVault_V1.delegateStake": {
    "type": "external",
    "function_name": "delegateStake(address account, uint256 amount)",
    "analysis_result": "Allows `msg.sender` (a delegate) to stake `amount` of the staking token on behalf of another `account`. It is guarded by `nonReentrant` and `whenNotPaused`. It checks if `msg.sender` is not the `account` itself. It calls the inherited `_stake(account, amount)` to transfer tokens and update the account's total staked balance. Then, it updates the internal `_delegateStake` mapping: it increments the `delegateTotalStaked` for the `account` and increments the `stakedByDelegate` amount for `msg.sender` under the `account`. Uses unchecked arithmetic for increments, relying on `_stake` handling the total supply increment which bounds `delegateTotalStaked`. Emits the `DelegateStaked` event. State variables modified: `_accountInfo`, `_totalSupply` (via `_stake`), `_delegateStake[account].delegateTotalStaked`, `_delegateStake[account].stakedByDelegate[msg.sender]`. Modifiers: `nonReentrant`, `whenNotPaused`. Errors: Reverts with `NotDelegate` if `msg.sender` is the same as `account`."
  },
  "RewardVault_V1.withdraw": {
    "type": "external",
    "function_name": "withdraw(uint256 amount)",
    "analysis_result": "Allows `msg.sender` to withdraw a self-staked `amount` of the staking token. It is guarded by `nonReentrant`. It uses the `checkSelfStakedBalance(msg.sender, amount)` modifier to ensure the amount does not exceed the self-staked balance. It calls the inherited `_withdraw(msg.sender, amount)` from `StakingRewards` to handle the core withdrawal logic (updating account balance and total supply and transferring tokens out). State variables modified: `_accountInfo`, `_totalSupply` (via `_withdraw`). Modifiers: `nonReentrant`, `checkSelfStakedBalance`."
  },
  "RewardVault_V1.delegateWithdraw": {
    "type": "external",
    "function_name": "delegateWithdraw(address account, uint256 amount)",
    "analysis_result": "Allows `msg.sender` (a delegate) to withdraw `amount` of the staking token they previously staked on behalf of an `account`. It is guarded by `nonReentrant`. It checks if `msg.sender` is not the `account` itself. It retrieves the amount `stakedByDelegate` for `msg.sender` on behalf of `account`. It checks if this amount is sufficient for the withdrawal. If sufficient, it decrements the `stakedByDelegate` amount for `msg.sender` under `account` and decrements the `delegateTotalStaked` for the `account` in the `_delegateStake` mapping, using unchecked arithmetic which is safe due to the prior balance check. It then calls the inherited `_withdraw(account, amount)` to update the account's total staked balance and transfer tokens out. Emits the `DelegateWithdrawn` event. State variables modified: `_delegateStake[account].stakedByDelegate[msg.sender]`, `_delegateStake[account].delegateTotalStaked`, `_accountInfo`, `_totalSupply` (via `_withdraw`). Modifiers: `nonReentrant`. Errors: Reverts with `NotDelegate` if `msg.sender` is the same as `account`. Reverts with `InsufficientDelegateStake` if the amount staked by the delegate for the account (`stakedByDelegate`) is less than the withdrawal `amount`."
  },
  "RewardVault_V1.getReward": {
    "type": "external",
    "function_name": "getReward(address account, address recipient)",
    "analysis_result": "Allows the `account` or its designated operator (`msg.sender`) to claim pending BGT rewards for the `account` and transfer them to the specified `recipient`. It is guarded by `nonReentrant` and `onlyOperatorOrUser(account)`. It calls the inherited `_getReward(account, recipient)` from `StakingRewards` to calculate and transfer the earned rewards. Returns the amount of reward claimed. State variables modified: `_accountInfo[account].rewardPerTokenPaid`, `_accountInfo[account].rewards` (via `_getReward`), `rewardToken.balance` (via `_safeTransferRewardToken`). Modifiers: `nonReentrant`, `onlyOperatorOrUser`. External calls: `_safeTransferRewardToken` (internal override which calls `rewardToken.safeTransferFrom`)."
  },
  "RewardVault_V1.exit": {
    "type": "external",
    "function_name": "exit(address recipient)",
    "analysis_result": "Allows `msg.sender` to withdraw their entire self-staked balance and claim their pending BGT rewards, transferring both to the `recipient`. It is guarded by `nonReentrant`. It calculates the self-staked amount by subtracting the total delegated stake (`_delegateStake[msg.sender].delegateTotalStaked`) from the account's total staked balance (`_accountInfo[msg.sender].balance`). It calls the inherited `_withdraw(msg.sender, amount)` to withdraw the self-staked amount. It then calls `_getReward(msg.sender, recipient)` to claim and transfer the BGT rewards to the `recipient`. State variables modified: `_accountInfo`, `_totalSupply` (via `_withdraw`), `_accountInfo[msg.sender].rewardPerTokenPaid`, `_accountInfo[msg.sender].rewards` (via `_getReward`), `stakeToken.balance` (via `_withdraw`), `rewardToken.balance` (via `_safeTransferRewardToken`). State variables checked: `_accountInfo[msg.sender].balance`, `_delegateStake[msg.sender].delegateTotalStaked`. Modifiers: `nonReentrant`. External calls: `_safeTransferRewardToken` (internal override called by `_getReward`)."
  },
  "RewardVault_V1.setOperator": {
    "type": "external",
    "function_name": "setOperator(address _operator)",
    "analysis_result": "Allows `msg.sender` to set an operator address that is permitted to act on their behalf (specifically, call `getReward` using the `onlyOperatorOrUser` modifier). It updates the `_operators` mapping for `msg.sender`. Emits the `OperatorSet` event. State variables modified: `_operators[msg.sender]`."
  },
  "RewardVault_V1.addIncentive": {
    "type": "external",
    "function_name": "addIncentive(address token, uint256 amount, uint256 incentiveRate)",
    "analysis_result": "Allows the designated manager of a whitelisted incentive `token` to add more `amount` of the token to the contract and potentially update the `incentiveRate`. It is guarded by `nonReentrant` and `onlyWhitelistedToken`. It checks if the provided `incentiveRate` does not exceed `MAX_INCENTIVE_RATE`. It checks if `msg.sender` is the correct manager for the token as stored in `incentives[token].manager`. It checks if the added `amount` is at least the token's `minIncentiveRate`. It uses `SafeERC20.safeTransferFrom` to pull the `amount` from `msg.sender` to the contract. It updates the `amountRemaining` for the token in the `incentives` mapping. It allows updating the `incentiveRate` if the previous `amountRemaining` was zero and the new `incentiveRate` is >= `minIncentiveRate`, OR if the new `incentiveRate` is greater than the stored one and the added `amount` is sufficient to cover the increased cost of incentivizing the remaining BGT (calculated using `FixedPointMathLib.mulDiv`). Emits the `IncentiveAdded` event. State variables modified: `incentives[token].amountRemaining`, `incentives[token].incentiveRate`. State variables checked: `incentives[token].minIncentiveRate`, `incentives[token].incentiveRate`, `incentives[token].amountRemaining`, `incentives[token].manager`. Modifiers: `nonReentrant`, `onlyWhitelistedToken`. External calls: `IERC20(token).safeTransferFrom`. Errors: Reverts with `IncentiveRateTooHigh` if `incentiveRate` exceeds `MAX_INCENTIVE_RATE`. Reverts with `NotIncentiveManager` if `msg.sender` is not the stored manager for the token. Reverts with `AmountLessThanMinIncentiveRate` if the `amount` is less than the token's `minIncentiveRate`."
  },
  "RewardVault_V1._checkSelfStakedBalance": {
    "type": "internal",
    "function_name": "_checkSelfStakedBalance(address account, uint256 amount)",
    "analysis_result": "This internal helper function calculates the self-staked balance for an `account` (total balance minus delegated stake) and checks if it is greater than or equal to the provided `amount`. Used by the `checkSelfStakedBalance` modifier and indirectly by `exit`. State variables checked: `_accountInfo[account].balance`, `_delegateStake[account].delegateTotalStaked`. Errors: Reverts with `InsufficientSelfStake` if the self-staked balance is less than the `amount`."
  },
  "RewardVault_V1._safeTransferRewardToken": {
    "type": "internal",
    "function_name": "_safeTransferRewardToken(address to, uint256 amount)",
    "analysis_result": "This internal override function is part of the `StakingRewards` inheritance. It is responsible for transferring the main reward token (BGT) from the `distributor` to the specified `to` address with the given `amount`. It uses `SafeERC20.safeTransferFrom` to pull tokens from the distributor's balance which must have granted allowance to the vault. State variables checked: `rewardToken`. External calls: `rewardToken.safeTransferFrom`. This function is called internally by the inherited `_getReward`."
  },
  "RewardVault_V1._checkRewardSolvency": {
    "type": "internal",
    "function_name": "_checkRewardSolvency()",
    "analysis_result": "This internal view override function is part of the `StakingRewards` inheritance. It checks if the contract has enough allowance from the `distributor` to cover the `undistributedRewards`. This prevents potential overflows in reward calculation functions if the allowance is too low compared to the `undistributedRewards`. State variables checked: `undistributedRewards`, `distributor`, `rewardToken`. External calls: `rewardToken.allowance`. Errors: Reverts with `InsolventReward` if `undistributedRewards / PRECISION` is greater than the `distributor`'s allowance to the vault."
  },
  "RewardVault_V1._processIncentives": {
    "type": "internal",
    "function_name": "_processIncentives(bytes calldata pubkey, uint256 bgtEmitted)",
    "analysis_result": "This internal function is called after a BGT reward is notified by the `distributor`. It iterates through all whitelisted incentive tokens (`whitelistedTokens`). For each token, it calculates the potential incentive `amount` based on the `bgtEmitted` and the token's `incentiveRate` using `FixedPointMathLib.mulDiv`. It caps this amount at the `amountRemaining` for the token. It then calculates the validator's share (`validatorShare`) using `beraChef.getValidatorIncentiveTokenShare`. If `validatorShare` is greater than 0, it attempts to transfer the `validatorShare` to the validator's operator address (retrieved from `beaconDepositContract.getOperator`) using `token.trySafeTransfer`. If successful, it updates `amountRemaining` and emits `IncentivesProcessed`. If `amount` (remaining after validator share) is greater than 0, it attempts to transfer this remaining amount to the `bgtIncentiveDistributor` contract for BGT boosters. This is done in two steps using low-level calls with a `SAFE_GAS_LIMIT`: first, it approves the `bgtIncentiveDistributor` to spend the `amount` using `IERC20.approve`. If successful, it then calls `IBGTIncentiveDistributor.receiveIncentive` on the distributor contract. If the second call succeeds, it updates `amountRemaining` and emits `BGTBoosterIncentivesProcessed`. If either the approve or the receive call fails, it emits `BGTBoosterIncentivesProcessFailed`. If the approve failed and the token requires allowance to be zero before setting a new one (like USDT), it attempts to reset the allowance to zero. Finally, it updates `incentive.amountRemaining` for the token. State variables modified: `incentives[token].amountRemaining`. State variables checked: `whitelistedTokens`, `incentives[token].incentiveRate`, `incentives[token].amountRemaining`. External calls: `beaconDepositContract.getOperator`, `IDistributor(distributor).beraChef`, `beraChef.getValidatorIncentiveTokenShare`, `token.trySafeTransfer`, `token.call` (for approve and receiveIncentive). Libraries used: `FixedPointMathLib`, `Utils` (for address.call). Note: Low-level calls with `SAFE_GAS_LIMIT` are used for efficiency but require careful error handling (checking the success boolean). This function handles failures by logging events and attempting to reset allowance if approve failed and receiveIncentive was attempted."
  },
  "RewardVault_V1._deleteWhitelistedTokenFromList": {
    "type": "internal",
    "function_name": "_deleteWhitelistedTokenFromList(address token)",
    "analysis_result": "This internal helper function removes a `token` address from the `whitelistedTokens` array. It iterates through the array to find the `token`. Once found, it replaces the found element with the last element in the array and then pops the last element, effectively removing the token without leaving a gap. It assumes the token exists in the list (guaranteed by `onlyWhitelistedToken` modifier on functions calling it). State variables modified: `whitelistedTokens`."
  },
  "IRewardVault_V1.distributor": {
    "type": "external",
    "function_name": "distributor() external view returns (address)",
    "analysis_result": "This is a view function that returns the address currently authorized to distribute rewards within the vault. It does not modify state variables. The actual storage variable holding the distributor address is expected to be in the implementing contract."
  },
  "IRewardVault_V1.operator": {
    "type": "external",
    "function_name": "operator(address account) external view returns (address)",
    "analysis_result": "This is a view function that queries and returns the address of the designated operator for a specific `account`. An operator is typically allowed to manage or claim rewards on behalf of the `account`. The mapping or storage structure storing operator assignments is expected to be in the implementing contract."
  },
  "IRewardVault_V1.getWhitelistedTokensCount": {
    "type": "external",
    "function_name": "getWhitelistedTokensCount() external view returns (uint256)",
    "analysis_result": "This is a view function that returns the current count of incentive tokens that have been whitelisted for use in the vault. This count is derived from an internal list or mapping managed by the implementing contract."
  },
  "IRewardVault_V1.getWhitelistedTokens": {
    "type": "external",
    "function_name": "getWhitelistedTokens() external view returns (address[] memory)",
    "analysis_result": "This is a view function that returns a dynamic array containing the addresses of all currently whitelisted incentive tokens. The list of whitelisted tokens is maintained internally by the implementing contract."
  },
  "IRewardVault_V1.getTotalDelegateStaked": {
    "type": "external",
    "function_name": "getTotalDelegateStaked(address account) external view returns (uint256)",
    "analysis_result": "This is a view function that returns the total amount of staking tokens that have been staked by various delegates specifically on behalf of the provided `account`. This aggregates stake amounts from different delegate addresses associated with the `account` in the implementing contract's storage."
  },
  "IRewardVault_V1.getDelegateStake": {
    "type": "external",
    "function_name": "getDelegateStake(address account, address delegate) external view returns (uint256)",
    "analysis_result": "This is a view function that returns the specific amount of staking tokens that the `delegate` address has staked on behalf of the `account` address. This accesses a specific entry in a mapping or nested structure storing delegate stake amounts in the implementing contract."
  },
  "IRewardVault_V1.initialize": {
    "type": "external",
    "function_name": "initialize(address _berachef, address _bgt, address _distributor, address _stakingToken) external",
    "analysis_result": "This function is intended for initial setup of the vault contract upon deployment. It takes the addresses of key external dependencies: `_berachef`, `_bgt` (BGT token), `_distributor` (reward distributor), and `_stakingToken`. It is designed to be called only once, likely by the contract factory that deploys it, and is expected to store these addresses in corresponding storage variables in the implementing contract."
  },
  "IRewardVault_V1.setDistributor": {
    "type": "external",
    "function_name": "setDistributor(address _rewardDistribution) external",
    "analysis_result": "This function allows updating the address authorized to distribute rewards (`_rewardDistribution`). It is an administrative function, likely restricted to the factory owner or another privileged role, and modifies the distributor storage variable in the implementing contract. Emits a `DistributorSet` event."
  },
  "IRewardVault_V1.notifyRewardAmount": {
    "type": "external",
    "function_name": "notifyRewardAmount(bytes calldata pubkey, uint256 reward) external",
    "analysis_result": "This function is intended for the authorized distributor (`distributor()`) to inform the vault about the amount of rewards (`reward`) available for a specific validator identified by its `pubkey`. This is a key part of the reward distribution mechanism. It updates internal reward tracking state in the implementing contract."
  },
  "IRewardVault_V1.recoverERC20": {
    "type": "external",
    "function_name": "recoverERC20(address tokenAddress, uint256 tokenAmount) external",
    "analysis_result": "This function allows a privileged address (likely the factory owner) to recover arbitrary ERC20 tokens (`tokenAddress`) and a specified `tokenAmount` that may have been accidentally sent to the vault contract. It calls `transfer()` on the `tokenAddress` contract to move the tokens out. Emits a `Recovered` event."
  },
  "IRewardVault_V1.setRewardsDuration": {
    "type": "external",
    "function_name": "setRewardsDuration(uint256 _rewardsDuration) external",
    "analysis_result": "This function is an administrative function, likely restricted to the factory owner, to update the duration (`_rewardsDuration`) over which notified rewards are intended to be distributed. This affects the rate at which rewards accrue to stakers. It modifies an internal storage variable related to reward timing."
  },
  "IRewardVault_V1.whitelistIncentiveToken": {
    "type": "external",
    "function_name": "whitelistIncentiveToken(address token, uint256 minIncentiveRate, address manager) external",
    "analysis_result": "This function allows a privileged address (likely the factory owner) to add a new token (`token`) to the list of supported incentive tokens. It requires specifying a `minIncentiveRate` and the address (`manager`) that is authorized to add incentives of this token type. It updates the list/mapping of whitelisted tokens and their associated data in the implementing contract. Emits an `IncentiveTokenWhitelisted` event. It likely checks against `maxIncentiveTokensCount`."
  },
  "IRewardVault_V1.removeIncentiveToken": {
    "type": "external",
    "function_name": "removeIncentiveToken(address token) external",
    "analysis_result": "This function allows a privileged address (likely the factory vault manager) to remove an existing incentive token (`token`) from the whitelist. It updates the list/mapping of whitelisted tokens in the implementing contract. Emits an `IncentiveTokenRemoved` event."
  },
  "IRewardVault_V1.setMaxIncentiveTokensCount": {
    "type": "external",
    "function_name": "setMaxIncentiveTokensCount(uint8 _maxIncentiveTokensCount) external",
    "analysis_result": "This function allows a privileged address (likely the factory owner) to set the maximum allowed number of whitelisted incentive tokens (`_maxIncentiveTokensCount`). It updates a storage variable defining this limit. Emits a `MaxIncentiveTokensCountUpdated` event."
  },
  "IRewardVault_V1.pause": {
    "type": "external",
    "function_name": "pause() external",
    "analysis_result": "This function allows a privileged address (likely the factory vault pauser) to pause certain operations within the vault contract, typically staking, withdrawing, claiming, etc. It likely toggles or sets a boolean `paused` storage variable, potentially using an inherited `Pausable` contract pattern."
  },
  "IRewardVault_V1.unpause": {
    "type": "external",
    "function_name": "unpause() external",
    "analysis_result": "This function allows a privileged address (likely the factory vault manager) to unpause the vault contract, allowing previously restricted operations to resume. It likely toggles or unsets a boolean `paused` storage variable."
  },
  "IRewardVault_V1.exit": {
    "type": "external",
    "function_name": "exit(address recipient) external",
    "analysis_result": "This function allows the `msg.sender` (the account holder) to exit the vault. This typically involves withdrawing their entire self-staked balance of the staking token and claiming any accumulated rewards (BGT and potentially incentive tokens). The claimed BGT reward is sent to the specified `recipient`. It clears the user's self-staked balance and reward state in the implementing contract. This function is specifically for self-stake and cannot be called by an operator for another account's self-stake."
  },
  "IRewardVault_V1.getReward": {
    "type": "external",
    "function_name": "getReward(address account, address recipient) external returns (uint256)",
    "analysis_result": "This function allows an `account` holder or their designated `operator(account)` to claim accumulated rewards (primarily BGT) for the specified `account`. The claimed reward amount is transferred to the `recipient` address. It updates the reward state for the `account` in the implementing contract and returns the amount of BGT claimed. The operator functionality is limited to claiming BGT rewards, not managing staking token balances."
  },
  "IRewardVault_V1.stake": {
    "type": "external",
    "function_name": "stake(uint256 amount) external",
    "analysis_result": "This function allows the `msg.sender` to stake a specified `amount` of the staking token in the vault. It requires the `msg.sender` to have approved the vault contract to spend the `amount` of staking tokens. It updates the `msg.sender`'s self-staked balance in the implementing contract and potentially updates total staked supply."
  },
  "IRewardVault_V1.delegateStake": {
    "type": "external",
    "function_name": "delegateStake(address account, uint256 amount) external",
    "analysis_result": "This function allows the `msg.sender` (acting as a delegate) to stake a specified `amount` of the staking token on behalf of another `account`. The `msg.sender` must have approved the vault contract to spend the tokens. It updates the stake balance associated with the `delegate` and `account` pair, as well as the total delegate stake for the `account`, in the implementing contract. Emits a `DelegateStaked` event."
  },
  "IRewardVault_V1.withdraw": {
    "type": "external",
    "function_name": "withdraw(uint256 amount) external",
    "analysis_result": "This function allows the `msg.sender` to withdraw a specified `amount` of their self-staked tokens from the vault. It requires the `msg.sender` to have sufficient self-staked balance. It decreases the `msg.sender`'s self-staked balance in the implementing contract and transfers the staking tokens to the `msg.sender`. It cannot be used by an operator for the account holder's self-stake."
  },
  "IRewardVault_V1.delegateWithdraw": {
    "type": "external",
    "function_name": "delegateWithdraw(address account, uint256 amount) external",
    "analysis_result": "This function allows the `msg.sender` (acting as a delegate) to withdraw a specified `amount` of tokens that *they* previously staked on behalf of the specified `account`. It requires the `msg.sender` to have sufficient stake recorded under the `account`/`delegate` pair. It decreases the stake balance associated with this pair and the total delegate stake for the `account` in the implementing contract and transfers the staking tokens to the `msg.sender`. Emits a `DelegateWithdrawn` event."
  },
  "IRewardVault_V1.setOperator": {
    "type": "external",
    "function_name": "setOperator(address _operator) external",
    "analysis_result": "This function allows the `msg.sender` (an account holder) to designate an `_operator` address. This operator will be permitted to call `getReward()` on behalf of the `msg.sender` to claim rewards. It updates the operator mapping for the `msg.sender` in the implementing contract. Emits an `OperatorSet` event."
  },
  "IRewardVault_V1.updateIncentiveManager": {
    "type": "external",
    "function_name": "updateIncentiveManager(address token, address newManager) external",
    "analysis_result": "This function is an administrative function, likely restricted to the factory owner, allowing the manager address (`newManager`) for a specific whitelisted incentive `token` to be changed. It updates the manager associated with the token in the implementing contract's storage. Emits an `IncentiveManagerChanged` event."
  },
  "IRewardVault_V1.addIncentive": {
    "type": "external",
    "function_name": "addIncentive(address token, uint256 amount, uint256 incentiveRate) external",
    "analysis_result": "This function allows the designated `manager` for a whitelisted incentive `token` to add a specified `amount` of that token to the vault as incentives. It also requires specifying the `incentiveRate`, which is the amount of this token to distribute per unit of BGT emission. The tokens are transferred to the vault contract. This function updates the internal state tracking incentive token balances and rates in the implementing contract. A warning is provided about potential transfer gas limits for the incentive token. Emits an `IncentiveAdded` event."
  },
  "IBeraChef_V1.getActiveRewardAllocation": {
    "type": "external",
    "function_name": "getActiveRewardAllocation(bytes calldata valPubkey) external view returns (RewardAllocation memory)",
    "analysis_result": "Retrieves the currently active reward allocation for a specific validator identified by their public key (`valPubkey`). This function is a read-only (`view`) operation. It takes the validator's public key as input and returns a `RewardAllocation` struct containing the start block and an array of `Weight` structs representing the distribution percentages to various receivers."
  },
  "IBeraChef_V1.getQueuedRewardAllocation": {
    "type": "external",
    "function_name": "getQueuedRewardAllocation(bytes calldata valPubkey) external view returns (RewardAllocation memory)",
    "analysis_result": "Retrieves the reward allocation that has been queued but is not yet active for a specific validator identified by their public key (`valPubkey`). This function is a read-only (`view`) operation. It takes the validator's public key as input and returns a `RewardAllocation` struct containing the start block and an array of `Weight` structs representing the intended future distribution percentages. Returns an empty struct if no allocation is queued."
  },
  "IBeraChef_V1.getSetActiveRewardAllocation": {
    "type": "external",
    "function_name": "getSetActiveRewardAllocation(bytes calldata valPubkey) external view returns (RewardAllocation memory)",
    "analysis_result": "Retrieves the reward allocation that was explicitly *set* by the validator with the given public key (`valPubkey`). This function is a read-only (`view`) operation. It returns the specific allocation configuration set by the validator, regardless of whether it is currently active or even valid. This provides insight into the validator's desired allocation settings."
  },
  "IBeraChef_V1.getDefaultRewardAllocation": {
    "type": "external",
    "function_name": "getDefaultRewardAllocation() external view returns (RewardAllocation memory)",
    "analysis_result": "Retrieves the system-wide default reward allocation configuration. This allocation is used for validators that have not set their own custom reward allocation. This function is a read-only (`view`) operation and takes no arguments. It returns a `RewardAllocation` struct."
  },
  "IBeraChef_V1.isQueuedRewardAllocationReady": {
    "type": "external",
    "function_name": "isQueuedRewardAllocationReady(bytes calldata valPubkey, uint256 blockNumber) external view returns (bool)",
    "analysis_result": "Checks if the queued reward allocation for a specific validator (`valPubkey`) is ready to be activated at a given block number (`blockNumber`). Activation typically depends on the queued allocation's `startBlock` being reached, potentially considering a delay. This function is a read-only (`view`) operation and returns a boolean indicating readiness."
  },
  "IBeraChef_V1.isReady": {
    "type": "external",
    "function_name": "isReady() external view returns (bool)",
    "analysis_result": "Checks if the BeraChef contract is initialized and ready for operation. The contract is considered ready if the governance module has set the default reward allocation. This function is a read-only (`view`) operation and takes no arguments. It returns a boolean indicating the contract's readiness state, primarily for external contracts depending on it."
  },
  "IBeraChef_V1.getValQueuedCommissionOnIncentiveTokens": {
    "type": "external",
    "function_name": "getValQueuedCommissionOnIncentiveTokens(bytes calldata valPubkey) external view returns (QueuedCommissionRateChange memory)",
    "analysis_result": "Retrieves the pending (queued) commission rate change for a validator on incentive tokens. The validator is identified by their public key (`valPubkey`). This function is a read-only (`view`) operation. It returns a `QueuedCommissionRateChange` struct containing the block number when the change was queued (`blockNumberLast`) and the queued commission rate (`commissionRate`). Returns an empty struct if no change is queued."
  },
  "IBeraChef_V1.getValCommissionOnIncentiveTokens": {
    "type": "external",
    "function_name": "getValCommissionOnIncentiveTokens(bytes calldata valPubkey) external view returns (uint96)",
    "analysis_result": "Retrieves the currently active commission rate applied to incentive tokens for a specific validator (`valPubkey`). This function is a read-only (`view`) operation. It takes the validator's public key as input and returns their active commission rate as a `uint96`. The documentation notes a default rate of 5% if the commission has never been explicitly set."
  },
  "IBeraChef_V1.getValidatorIncentiveTokenShare": {
    "type": "external",
    "function_name": "getValidatorIncentiveTokenShare(bytes calldata valPubkey, uint256 incentiveTokenAmount) external view returns (uint256)",
    "analysis_result": "Calculates the portion of a given amount of incentive tokens (`incentiveTokenAmount`) that should be allocated to a validator based on their active commission rate. The validator is identified by their public key (`valPubkey`). This function is a read-only (`view`) operation. It takes the validator's public key and the total incentive token amount as inputs and returns the calculated validator's share."
  },
  "IBeraChef_V1.setMaxNumWeightsPerRewardAllocation": {
    "type": "external",
    "function_name": "setMaxNumWeightsPerRewardAllocation(uint8 _maxNumWeightsPerRewardAllocation) external",
    "analysis_result": "Allows setting the maximum allowed number of entries (`Weight` structs) within the `weights` array of a `RewardAllocation`. This limits how many distinct receivers a validator can include in their allocation. This is an administrative function, likely intended for governance control, and takes the maximum number as a `uint8`."
  },
  "IBeraChef_V1.setRewardAllocationBlockDelay": {
    "type": "external",
    "function_name": "setRewardAllocationBlockDelay(uint64 _rewardAllocationBlockDelay) external",
    "analysis_result": "Allows setting a minimum delay in blocks (`_rewardAllocationBlockDelay`) that must pass after a new reward allocation is queued before it becomes eligible for activation. This prevents immediate changes. This is an administrative function, likely intended for governance control, and takes the delay as a `uint64`."
  },
  "IBeraChef_V1.setVaultWhitelistedStatus": {
    "type": "external",
    "function_name": "setVaultWhitelistedStatus(address receiver, bool isWhitelisted, string memory metadata) external",
    "analysis_result": "Allows the governance module to update the whitelisted status of a specific address (`receiver`), typically a vault or distribution contract. If `isWhitelisted` is true, the address is added/marked as whitelisted; otherwise, it's removed. Metadata (`metadata`) can be associated with the address, primarily for event logging. This function explicitly requires the caller to be the governance module account."
  },
  "IBeraChef_V1.updateWhitelistedVaultMetadata": {
    "type": "external",
    "function_name": "updateWhitelistedVaultMetadata(address receiver, string memory metadata) external",
    "analysis_result": "Allows the governance module to update the metadata string (`metadata`) associated with an address (`receiver`) that is already whitelisted. This function is used to modify the metadata without changing the whitelisted status itself. It explicitly requires the caller to be the governance module account and will revert if the receiver address is not currently whitelisted."
  },
  "IBeraChef_V1.setDefaultRewardAllocation": {
    "type": "external",
    "function_name": "setDefaultRewardAllocation(RewardAllocation calldata rewardAllocation) external",
    "analysis_result": "Allows the governance module to set the default reward allocation (`rewardAllocation`) that will be used by validators who do not specify their own custom allocation. This function takes a `RewardAllocation` struct as input. It explicitly requires the caller to be the governance module account and is crucial for initializing the contract's ready state."
  },
  "IBeraChef_V1.queueNewRewardAllocation": {
    "type": "external",
    "function_name": "queueNewRewardAllocation(bytes calldata valPubkey, uint64 startBlock, Weight[] calldata weights) external",
    "analysis_result": "Allows a validator (likely via their operator address) to queue a new desired reward allocation configuration. The allocation includes a `startBlock` for activation and an array of `weights` distributing rewards to receivers. This function validates that the weights sum to 100% (1e4) and that all specified receivers are whitelisted vaults. It will revert if the validator already has a pending queued allocation. This initiates the process for a validator to change their reward distribution."
  },
  "IBeraChef_V1.activateReadyQueuedRewardAllocation": {
    "type": "external",
    "function_name": "activateReadyQueuedRewardAllocation(bytes calldata valPubkey) external",
    "analysis_result": "Attempts to activate the queued reward allocation for a specific validator (`valPubkey`). This function checks if the queued allocation is ready for activation based on its `startBlock` and the defined block delay (potentially using the `isQueuedRewardAllocationReady` logic internally). It is expected to be called by a distribution contract or similar automated process to transition a queued allocation to the active state when its conditions are met."
  },
  "IBeraChef_V1.setCommissionChangeDelay": {
    "type": "external",
    "function_name": "setCommissionChangeDelay(uint64 _commissionChangeDelay) external",
    "analysis_result": "Allows setting a minimum delay in blocks (`_commissionChangeDelay`) that must pass after a validator queues a commission rate change before it becomes eligible for activation. This is an administrative function to manage the timing of commission updates. The documentation states that only the owner can call this function."
  },
  "IBeraChef_V1.queueValCommission": {
    "type": "external",
    "function_name": "queueValCommission(bytes calldata valPubkey, uint96 commissionRate) external",
    "analysis_result": "Allows a validator (likely via their operator address) to queue a desired change to their commission rate on incentive tokens. The validator is identified by their public key (`valPubkey`), and the new `commissionRate` is provided as a `uint96`. This function initiates the process for a validator to change their commission rate. It will revert if the validator already has a pending queued commission change."
  },
  "IBeraChef_V1.activateQueuedValCommission": {
    "type": "external",
    "function_name": "activateQueuedValCommission(bytes calldata valPubkey) external",
    "analysis_result": "Attempts to activate the queued commission rate change for a specific validator (`valPubkey`). This function likely checks if the commission change delay has passed since the change was queued. It is expected to be called to transition a queued commission rate to the active state once the delay condition is met."
  },
  "TimeLock.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor for the TimeLock contract. It is marked with `/// @custom:oz-upgrades-unsafe-allow constructor` because constructors are typically disallowed in upgradeable contracts (initialization should happen in an `initialize` function). The purpose of this constructor is solely to call `_disableInitializers()`. This function, inherited from `UUPSUpgradeable`, marks the implementation contract as initialized, preventing its `initialize` function from being called directly. Initialization logic for the proxy is expected to be handled separately via the proxy's `initialize` call."
  },
  "TimeLock._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This internal function is an override from `UUPSUpgradeable`. Its purpose is to implement the authorization logic for upgrading the contract proxy to a new implementation address (`newImplementation`). The function uses the `onlyRole(DEFAULT_ADMIN_ROLE)` modifier. This means that only an address holding the `DEFAULT_ADMIN_ROLE` (inherited from `TimelockControllerUpgradeable`'s parent `AccessControlUpgradeable`) can successfully call this function (or rather, be the caller initiating the upgrade which triggers this check). The function body is empty, meaning that if the `onlyRole` check passes, the upgrade is authorized. It checks the caller's role against the stored state of roles inherited from `AccessControlUpgradeable`. It does not modify any storage variables within this function body, but its successful execution allows the upgrade process in `UUPSUpgradeable` to proceed, which will update the proxy's storage pointer to the new implementation address."
  },
  "BerachainGovernance.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor for the upgradeable contract. It immediately calls _disableInitializers(), a standard OpenZeppelin UUPS pattern to prevent the initialize function from being called on the implementation contract directly. It does not use or modify any state variables itself."
  },
  "BerachainGovernance.initialize": {
    "type": "public",
    "function_name": "initialize(IVotes _token, TimelockControllerUpgradeable _timelock, InitialGovernorParameters memory params)",
    "analysis_result": "This is the main initialization function, protected by the 'initializer' modifier to ensure it can only be called once. It sets up all the inherited OpenZeppelin Governor modules. It calls __UUPSUpgradeable_init() for upgradeability setup, __Governor_init() to set the name to 'BerachainGovernance', __GovernorSettings_init() using params.votingDelay, params.votingPeriod, and params.proposalThreshold, __GovernorCountingSimple_init() for simple vote counting, __GovernorStorage_init() for upgradeable storage, __GovernorVotes_init() with the provided _token for voting power, __GovernorVotesQuorumFraction_init() with params.quorumNumeratorValue for quorum calculation, and __GovernorTimelockControl_init() with the provided _timelock to link the Governor to the TimelockController responsible for execution. It uses the input parameters _token (IVotes), _timelock (TimelockControllerUpgradeable), and params (struct containing proposalThreshold, quorumNumeratorValue, votingDelay, votingPeriod). These calls initialize various internal storage variables within the inherited modules."
  },
  "BerachainGovernance._authorizeUpgrade": {
    "type": "internal override",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This internal function overrides the UUPSUpgradeable requirement for authorizing upgrades. It is restricted by the 'onlyGovernance' modifier, which ensures that only a call originating from a successfully executed proposal by this Governor contract can trigger an upgrade. It takes the address of the new implementation contract (newImplementation) as input but does not use it directly within its body. The authorization logic is handled entirely by the 'onlyGovernance' modifier. It does not read or modify any storage variables directly; its purpose is purely access control for the upgrade process."
  },
  "BerachainGovernance._voteSucceeded": {
    "type": "internal view virtual override",
    "function_name": "_voteSucceeded(uint256 proposalId)",
    "analysis_result": "This internal view function overrides the default vote success logic. It takes proposalId as input. It calls proposalVotes(proposalId) to get the againstVotes and forVotes for the proposal. It calculates a custom success threshold as 51% of the sum of forVotes and againstVotes (abstain votes are excluded from this calculation). It returns true if forVotes is greater than or equal to this calculated threshold, implementing the requirement for a 51% approval threshold. It uses the input parameter proposalId and reads vote counts indirectly via the proposalVotes function, which accesses stored vote data. It does not modify storage."
  },
  "BerachainGovernance.getTimelockOperationId": {
    "type": "external view",
    "function_name": "getTimelockOperationId(uint256 proposalId)",
    "analysis_result": "This external view function calculates and returns the Timelock operation ID for a given proposal. It takes proposalId as input. It calls the internal _executor() function to get the TimelockController address and casts it. It calls the internal proposalDetails(proposalId) function to retrieve the targets, values, calldatas, and descriptionHash for the proposal. It calculates a salt for the operation ID by XORing the Governor's address (as bytes20) with the descriptionHash. Finally, it calls hashOperationBatch on the TimelockController instance with the proposal details, a delay of 0 (as it's Governor initiated), and the calculated salt to compute and return the operationId. It uses proposalId as input and relies on internal functions accessing stored proposal and executor data. It does not modify storage."
  },
  "BerachainGovernance._countVote": {
    "type": "internal override",
    "function_name": "_countVote(uint256 proposalId, address account, uint8 support, uint256 totalWeight, bytes memory params)",
    "analysis_result": "This internal function overrides the vote counting mechanism. It is called when a vote is cast. It takes proposalId, account (voter), support (vote type), totalWeight (voting power), and params (extra data) as input. It includes a specific check: if totalWeight is 0, it reverts with the custom GovernorZeroVoteWeight error using the selector. After this check, it delegates the actual counting logic to the inherited GovernorCountingSimpleUpgradeable module by calling GovernorCountingSimpleUpgradeable._countVote(...) with the same parameters. It uses all input parameters and indirectly modifies stored vote counts through the delegated call."
  },
  "BerachainGovernance.state": {
    "type": "public view override",
    "function_name": "state(uint256 proposalId)",
    "analysis_result": "This public view function is required to return the current state of a proposal. It takes proposalId as input. It simply calls and returns the result of the overridden function in GovernorTimelockControlUpgradeable by calling GovernorTimelockControlUpgradeable.state(proposalId). This module's state logic includes states related to Timelock interaction (Queued, Executed). It uses proposalId as input and reads stored proposal state data indirectly through the delegated call. It does not modify storage."
  },
  "BerachainGovernance.proposalNeedsQueuing": {
    "type": "public view override",
    "function_name": "proposalNeedsQueuing(uint256 proposalId)",
    "analysis_result": "This public view function determines if a successful proposal needs to be queued in the Timelock. It takes proposalId as input. It simply calls and returns the result of the overridden function in GovernorTimelockControlUpgradeable by calling GovernorTimelockControlUpgradeable.proposalNeedsQueuing(proposalId). This module handles the logic for checking if the proposal state necessitates queuing in the associated TimelockController. It uses proposalId as input and reads stored proposal state data indirectly through the delegated call. It does not modify storage."
  },
  "BerachainGovernance.proposalThreshold": {
    "type": "public view override",
    "function_name": "proposalThreshold()",
    "analysis_result": "This public view function returns the minimum voting power required to create a proposal. It takes no input. It simply calls and returns the result of the overridden function in GovernorSettingsUpgradeable by calling GovernorSettingsUpgradeable.proposalThreshold(). The threshold value is stored within the GovernorSettingsUpgradeable module, set during initialization. It does not use any parameters and reads the stored proposal threshold value indirectly. It does not modify storage."
  },
  "BerachainGovernance._propose": {
    "type": "internal override",
    "function_name": "_propose(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, string memory description, address proposer)",
    "analysis_result": "This internal function is responsible for creating a new proposal after access and threshold checks have passed. It takes targets, values, calldatas (defining the actions), description (text), and proposer as input. It simply calls and returns the result (the new proposalId) of the overridden function in GovernorStorageUpgradeable by calling GovernorStorageUpgradeable._propose(...) with the same parameters. This delegates the logic for storing the proposal data and managing proposal IDs to the storage module. It uses all input parameters and modifies storage by adding the new proposal data and incrementing the proposal counter within GovernorStorageUpgradeable."
  },
  "BerachainGovernance._queueOperations": {
    "type": "internal override",
    "function_name": "_queueOperations(uint256 proposalId, address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash)",
    "analysis_result": "This internal function is called to queue a successful proposal's operations in the associated TimelockController. It takes proposalId, targets, values, calldatas, and descriptionHash as input. It simply calls and returns the result (the queuing timestamp) of the overridden function in GovernorTimelockControlUpgradeable by calling GovernorTimelockControlUpgradeable._queueOperations(...) with the same parameters. This delegates the logic for interacting with the Timelock contract to schedule the operation batch. It uses all input parameters and modifies storage by updating the proposal state and queuing time, as well as interacting with the TimelockController to add an operation to its queue."
  },
  "BerachainGovernance._executeOperations": {
    "type": "internal override",
    "function_name": "_executeOperations(uint256 proposalId, address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash)",
    "analysis_result": "This internal function is called to execute a queued proposal's operations via the associated TimelockController. It takes proposalId, targets, values, calldatas, and descriptionHash as input. It simply calls the overridden function in GovernorTimelockControlUpgradeable by calling GovernorTimelockControlUpgradeable._executeOperations(...) with the same parameters. This delegates the logic for interacting with the Timelock contract to execute the queued operation batch. It uses all input parameters and modifies storage by updating the proposal state to Executed, as well as interacting with the TimelockController to execute a queued operation."
  },
  "BerachainGovernance._cancel": {
    "type": "internal override",
    "function_name": "_cancel(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash)",
    "analysis_result": "This internal function is called to cancel a proposal. It takes targets, values, calldatas, and descriptionHash as input, which identify the proposal to be cancelled. It simply calls and returns the result (the proposalId of the cancelled proposal) of the overridden function in GovernorTimelockControlUpgradeable by calling GovernorTimelockControlUpgradeable._cancel(...) with the same parameters. This delegates the logic for marking the proposal as cancelled and potentially cancelling the corresponding operation in the TimelockController to the GovernorTimelockControlUpgradeable module. It uses all input parameters and modifies storage by updating the proposal state to Canceled, as well as potentially interacting with the TimelockController to cancel an operation."
  },
  "BerachainGovernance._executor": {
    "type": "internal view override",
    "function_name": "_executor()",
    "analysis_result": "This internal view function is required to provide the address of the contract responsible for executing proposals, which is the linked TimelockController. It takes no input parameters. It simply calls and returns the result of the overridden function in GovernorTimelockControlUpgradeable by calling GovernorTimelockControlUpgradeable._executor(). The TimelockController address is stored within the GovernorTimelockControlUpgradeable module, set during initialization. It does not use any parameters and reads the stored executor address indirectly. It does not modify storage."
  },
  "GovDeployer.constructor": {
    "type": "constructor",
    "function_name": "constructor(address token, address guardian, uint256 proposalThreshold, uint256 votingDelay, uint256 votingPeriod, uint256 quorumNumeratorValue, uint256 timelockMinDelay, uint256 govSalt, uint256 timelockSalt)",
    "analysis_result": "The constructor is responsible for deploying and initializing the BerachainGovernance and TimeLock contracts using the CREATE2 opcode. It takes the token address, guardian address, various governance parameters (proposal threshold, voting delay, voting period, quorum numerator), timelock minimum delay, and two salts for CREATE2 deployment. It first validates the provided token address by calling `_checkIfERC20Votes` to ensure it supports the necessary interfaces (IVotes and IERC20Metadata). It then calls the internal `_deploy` function twice: once to deploy the BerachainGovernance contract using `govSalt`, and once to deploy the TimeLock contract using `timelockSalt`. The addresses of the deployed governor and timelock are stored in the immutable state variables `GOVERNOR` and `TIMELOCK_CONTROLLER` respectively. It initializes the deployed Timelock contract by calling its `initialize` function, setting the minimum delay, allowing the deployed governor address as proposer and executor, and temporarily granting itself (this deployer contract) the DEFAULT_ADMIN_ROLE to perform further setup. If a non-zero `guardian` address is provided, it grants the CANCELLER_ROLE on the Timelock to the guardian. It then revokes the DEFAULT_ADMIN_ROLE from itself on the Timelock. It calculates the actual proposal threshold value by scaling the input `proposalThreshold` with the token's decimal value obtained from `IERC20Metadata`. It initializes the deployed BerachainGovernance contract by calling its `initialize` function, passing the token address (cast to IVotes), the Timelock address (cast to TimelockControllerUpgradeable), and the calculated governance parameters. Finally, it asserts that the deployed governance contract's clock mode, obtained by calling `CLOCK_MODE()`, matches the expected `GOV_TOKEN_CLOCK_MODE` constant value ('mode=timestamp') to ensure EIP-6372 compatibility, reverting if they do not match. State variables modified are `GOVERNOR` and `TIMELOCK_CONTROLLER`. It calls internal functions `_checkIfERC20Votes` and `_deploy` (twice). It makes external calls to the deployed Timelock (`initialize`, `grantRole`, `revokeRole`), the deployed Governance (`initialize`, `CLOCK_MODE`), and the token contract (`decimals` via IERC20Metadata)."
  },
  "GovDeployer.GOVERNOR": {
    "type": "public",
    "function_name": "GOVERNOR()",
    "analysis_result": "This is a public getter function automatically generated for the public immutable state variable `GOVERNOR`. It allows external callers to retrieve the address of the deployed BerachainGovernance contract. It does not take any parameters and does not modify any state variables. It simply returns the value stored in the `GOVERNOR` variable."
  },
  "GovDeployer.TIMELOCK_CONTROLLER": {
    "type": "public",
    "function_name": "TIMELOCK_CONTROLLER()",
    "analysis_result": "This is a public getter function automatically generated for the public immutable state variable `TIMELOCK_CONTROLLER`. It allows external callers to retrieve the address of the deployed TimeLock contract. It does not take any parameters and does not modify any state variables. It simply returns the value stored in the `TIMELOCK_CONTROLLER` variable."
  },
  "GovDeployer._deploy": {
    "type": "internal",
    "function_name": "_deploy(bytes creationCode, uint256 salt)",
    "analysis_result": "This internal function is responsible for deploying both the implementation and the proxy contracts for a given contract using the CREATE2 opcode. It takes the `creationCode` of the contract type (e.g., `type(Contract).creationCode`) and a unique `salt` value. It first calls the inherited function `deployWithCreate2` (from `Create2Deployer`) with the provided `salt` and `creationCode` to deploy the implementation contract and returns its address. It then calls the inherited function `deployProxyWithCreate2` (from `Create2Deployer`) with the address of the just-deployed implementation and the same `salt` value to deploy a proxy contract pointing to that implementation. The function returns the address of the deployed proxy contract, cast to `address payable`. It does not directly modify any state variables of the `GovDeployer` contract, but it creates new contract instances on the blockchain. It calls the inherited functions `deployWithCreate2` and `deployProxyWithCreate2`."
  },
  "GovDeployer._checkIfERC20Votes": {
    "type": "internal",
    "function_name": "_checkIfERC20Votes(address token)",
    "analysis_result": "This internal function is used to validate if a given token address implements the necessary interfaces for the governance setup, specifically IVotes and IERC20Metadata. It takes the `token` address as input. It calls the internal view function `_supportsERC20VotesAndMetadata` with the token address. If `_supportsERC20VotesAndMetadata` returns `false`, meaning the token does not support the required interfaces, the function reverts with a specific error message. It does not modify any state variables. Its purpose is to enforce the requirement that the governance token must support voting and metadata features. It calls the internal view function `_supportsERC20VotesAndMetadata`."
  },
  "GovDeployer._supportsERC20VotesAndMetadata": {
    "type": "internal view",
    "function_name": "_supportsERC20VotesAndMetadata(address token)",
    "analysis_result": "This internal view function checks if a contract at the given `token` address implements both the IVotes and IERC20Metadata interfaces. It takes the `token` address as input. It uses a `try...catch` block to safely interact with the external token contract. Inside the `try` block, it first attempts to call `IVotes(token).getVotes(address(this))`. If this call succeeds (which indicates the IVotes interface is likely supported), it then attempts to call `IERC20Metadata(token).name()` and `IERC20Metadata(token).decimals()`. These calls check for the basic ERC20 metadata functions. If all calls within the `try` block complete successfully without reverting, the function returns `true`. If any of the calls inside the `try` block revert or fail (e.g., due to missing function selectors), the `catch` block is executed, and the function returns `false`. This allows for a safe check without crashing if the token address points to a contract that doesn't support the expected interfaces. It does not modify any state variables. It performs external calls to `getVotes` on the contract at the token address (cast as IVotes) and `name` and `decimals` on the contract at the token address (cast as IERC20Metadata)."
  },
  "PeggedPriceOracle._priceData": {
    "type": "internal",
    "function_name": "_priceData()",
    "analysis_result": "This is an internal helper function. Its purpose is to generate the fixed price data that this oracle will always return. It constructs an IPriceOracle.Data struct. The price is hardcoded to 1e18 (representing 1.0 with 18 decimal places), and the publishTime is set to the current block's timestamp (block.timestamp). It does not take any parameters, return any values other than the struct, call any other functions, read or modify any state variables, or use any modifiers. It provides the core fixed data used by all public/external price retrieval functions."
  },
  "PeggedPriceOracle.getPrice": {
    "type": "external",
    "function_name": "getPrice(address asset)",
    "analysis_result": "This function is part of the IPriceOracle interface implementation. Its purpose is to return the price data for a specified asset. It takes an 'asset' address as input but ignores it ('asset;' is a common way to signal the variable is intentionally unused to satisfy the compiler). It delegates the actual data retrieval to the internal helper function '_priceData()', effectively returning the fixed price (1e18) and current block timestamp regardless of the 'asset' provided. It returns an IPriceOracle.Data struct. It does not read or modify state variables or use modifiers."
  },
  "PeggedPriceOracle.getPriceUnsafe": {
    "type": "external",
    "function_name": "getPriceUnsafe(address asset)",
    "analysis_result": "This function is part of the IPriceOracle interface implementation, typically used when caller doesn't require strict staleness checks. Its purpose is to return the price data for a specified asset. Similar to 'getPrice', it takes an 'asset' address as input but ignores it ('asset;'). It calls the internal helper function '_priceData()' to get the fixed price (1e18) and current block timestamp. It returns an IPriceOracle.Data struct. It does not read or modify state variables or use modifiers. For this simple oracle, 'getPrice' and 'getPriceUnsafe' behave identically."
  },
  "PeggedPriceOracle.getPriceNoOlderThan": {
    "type": "external",
    "function_name": "getPriceNoOlderThan(address asset, uint256 age)",
    "analysis_result": "This function is part of the IPriceOracle interface implementation. Its purpose is to return price data for an asset only if the data is not older than a specified 'age'. It takes an 'asset' address and a 'age' (in seconds) as input, but ignores both parameters ('asset;', 'age;'). It calls the internal helper function '_priceData()', which always returns the current block timestamp as the publish time. Since the returned data is always 'current' relative to the block, it implicitly satisfies any 'age' requirement. It returns an IPriceOracle.Data struct. It does not read or modify state variables or use modifiers. The staleness check concept inherent in the function name is bypassed by always returning the current block timestamp."
  },
  "PeggedPriceOracle.priceAvailable": {
    "type": "external",
    "function_name": "priceAvailable(address asset)",
    "analysis_result": "This function is part of the IPriceOracle interface implementation. Its purpose is to indicate whether price data is available for a given asset. It is marked as 'pure' because it doesn't read from or write to the blockchain state. It takes an 'asset' address as input but ignores it ('asset;'). It unconditionally returns 'true', signifying that this oracle considers price data to be available for any requested asset at all times. It does not call other functions, read or modify state variables, or use modifiers."
  },
  "PythPriceOracleDeployer.constructor": {
    "type": "constructor",
    "function_name": "constructor(address governance, uint256 oracleSalt)",
    "analysis_result": "This is the constructor function of the PythPriceOracleDeployer contract. Its main purpose is to deploy and initialize a PythPriceOracle proxy contract using the CREATE2 opcode for predictable addresses. It takes two arguments: 'governance', which is the address that will be set as the governance for the initialized PythPriceOracle contract, and 'oracleSalt', a unique value used with CREATE2 to determine the proxy's final address. Inside the constructor, it first calls the inherited function `deployWithCreate2` (from the `Create2Deployer` base contract) to deploy the implementation contract of `PythPriceOracle`. It passes 0 as the salt (meaning no salt or the zero salt) and the creation code bytecode of the `PythPriceOracle` contract obtained via `type(PythPriceOracle).creationCode`. The address of the deployed implementation is stored in the local variable `oracleImpl`. Next, it calls the inherited function `deployProxyWithCreate2` to deploy the proxy contract. It passes the address of the deployed implementation (`oracleImpl`) and the provided `oracleSalt`. The address of the deployed proxy is cast to a `PythPriceOracle` type and assigned to the public immutable state variable `oracle`. Finally, it calls the `initialize` function on the newly deployed and assigned `oracle` proxy contract, passing the `governance` address as an argument. This sets up the initial state of the `PythPriceOracle` contract, specifically setting its governance address. The state variable `oracle` is modified to store the address of the deployed and initialized proxy."
  },
  "RootPriceOracle.MANAGER_ROLE": {
    "type": "public",
    "function_name": "MANAGER_ROLE",
    "analysis_result": "This is a public constant state variable of type bytes32. It stores the keccak256 hash of the string \"MANAGER_ROLE\". This value is used throughout the contract, specifically in the `onlyRole` modifier, to define a specific role for access control. Functions restricted by this role (e.g., `setSpotOracle`, `setPythOracle`) can only be called by addresses that have been granted the `MANAGER_ROLE` via the AccessControl mechanism. It is read by the `onlyRole` modifier."
  },
  "RootPriceOracle.WAD": {
    "type": "internal",
    "function_name": "WAD",
    "analysis_result": "This is an internal constant state variable of type uint256. It is initialized to 1 ether (1e18). This value represents the base unit for fixed-point arithmetic, equivalent to 1. It is specifically used within the `_selectLargestDeviation` function to compare prices from different oracles against the value of 1 (WAD) to determine their deviation. It is read within `_selectLargestDeviation`."
  },
  "RootPriceOracle.spotOracle": {
    "type": "public",
    "function_name": "spotOracle",
    "analysis_result": "This is a public state variable of type IPriceOracle. It stores the address of the contract implementing the `IPriceOracle` interface that serves as the spot price oracle. Being public, Solidity automatically generates a getter function allowing external parties to read the stored address. Its value is set by the `setSpotOracle` function and read by `_getAssetAvailability`, `getPrice`, `getPriceUnsafe`, and `getPriceNoOlderThan` when interacting with the spot oracle contract."
  },
  "RootPriceOracle.pythOracle": {
    "type": "public",
    "function_name": "pythOracle",
    "analysis_result": "This is a public state variable of type IPriceOracle. It stores the address of the contract implementing the `IPriceOracle` interface that serves as the Pyth price oracle. Being public, Solidity automatically generates a getter function allowing external parties to read the stored address. Its value is set by the `setPythOracle` function and read by `_getAssetAvailability`, `getPrice`, `getPriceUnsafe`, `getPriceNoOlderThan`, and `priceAvailable` when interacting with the Pyth oracle contract."
  },
  "RootPriceOracle.initialize": {
    "type": "external",
    "function_name": "initialize(address initialAdmin)",
    "analysis_result": "This external function is marked with the `initializer` modifier, indicating it's intended for use with upgradeable contracts to perform setup instead of a constructor. Its purpose is to set up the contract's initial state, specifically granting the `DEFAULT_ADMIN_ROLE` to a specified address. It takes one argument, `initialAdmin`, the address to receive the admin role. It first checks if `initialAdmin` is the zero address using `ZeroAddress.selector.revertWith()` from the imported `Utils` library; if it is, the transaction reverts. If the address is valid, it calls the internal `_grantRole` function (inherited from `AccessControl`) to assign the `DEFAULT_ADMIN_ROLE` to `initialAdmin`. This function modifies the internal state managed by the AccessControl contract to record the role assignment. It does not read or write other state variables of `RootPriceOracle` directly, but relies on the state of `AccessControl`."
  },
  "RootPriceOracle.setSpotOracle": {
    "type": "external",
    "function_name": "setSpotOracle(address spotOracle_)",
    "analysis_result": "This external function is restricted by the `onlyRole(MANAGER_ROLE)` modifier, meaning only addresses possessing the `MANAGER_ROLE` can execute it. Its purpose is to update the address of the spot price oracle contract. It takes one argument, `spotOracle_`, the address of the new spot oracle. It first checks if `spotOracle_` is the zero address using `ZeroAddress.selector.revertWith()`; if it is, the transaction reverts. If the address is valid and the caller has the required role, the function updates the state variable `spotOracle` with the provided address. Finally, it emits the `SpotOracleSet` event with the new oracle address. This function reads the caller's roles via the modifier and the function argument, and writes to the `spotOracle` state variable."
  },
  "RootPriceOracle.setPythOracle": {
    "type": "external",
    "function_name": "setPythOracle(address pythOracle_)",
    "analysis_result": "This external function is restricted by the `onlyRole(MANAGER_ROLE)` modifier, meaning only addresses possessing the `MANAGER_ROLE` can execute it. Its purpose is to update the address of the Pyth price oracle contract. It takes one argument, `pythOracle_`, the address of the new Pyth oracle. It first checks if `pythOracle_` is the zero address using `ZeroAddress.selector.revertWith()`; if it is, the transaction reverts. If the address is valid and the caller has the required role, the function updates the state variable `pythOracle` with the provided address. Finally, it emits the `PythOracleSet` event with the new oracle address. This function reads the caller's roles via the modifier and the function argument, and writes to the `pythOracle` state variable."
  },
  "RootPriceOracle.getPrice": {
    "type": "external",
    "function_name": "getPrice(address asset)",
    "analysis_result": "This external view function implements the `getPrice` method from the `IPriceOracle` interface. Its purpose is to provide reliable price data for a given `asset` address by combining data from the configured Pyth and Spot oracles. It first calls the internal helper function `_getAssetAvailability` to determine if price data is available for the asset in both oracles. It enforces a critical rule: if Pyth data is NOT available (`!pythAvailable`), the function reverts using `UnreliablePrice.selector.revertWith()`. If Pyth data IS available, it proceeds. If only Pyth data is available (`!spotAvailable`), it returns the result directly from `pythOracle.getPrice(asset)`. If both Pyth and Spot data are available, it fetches data from both using `pythOracle.getPrice(asset)` and `spotOracle.getPrice(asset)`, and then calls the internal helper function `_selectLargestDeviation` with these two data points. `_selectLargestDeviation` returns the `Data` struct with the price furthest from 1 WAD, which is then returned by this function. This function reads the `spotOracle` and `pythOracle` state variables (implicitly via external calls) and the `asset` argument. It does not modify state."
  },
  "RootPriceOracle.getPriceUnsafe": {
    "type": "external",
    "function_name": "getPriceUnsafe(address asset)",
    "analysis_result": "This external view function implements the `getPriceUnsafe` method from the `IPriceOracle` interface. Its purpose is similar to `getPrice` but uses the `getPriceUnsafe` method on the underlying oracles, which might provide less strict freshness guarantees. It follows the same logic as `getPrice`: it checks asset availability using `_getAssetAvailability`, requires Pyth data to be available (reverting if not), returns `pythOracle.getPriceUnsafe(asset)` if only Pyth is available, and calls `_selectLargestDeviation` with results from `pythOracle.getPriceUnsafe(asset)` and `spotOracle.getPriceUnsafe(asset)` if both are available. It reads `spotOracle`, `pythOracle`, and `asset` but modifies no state."
  },
  "RootPriceOracle.getPriceNoOlderThan": {
    "type": "external",
    "function_name": "getPriceNoOlderThan(address asset, uint256 age)",
    "analysis_result": "This external view function implements the `getPriceNoOlderThan` method from the `IPriceOracle` interface. Its purpose is similar to `getPrice` but requests data no older than a specified `age` from the underlying oracles. It follows the same core logic: checks asset availability using `_getAssetAvailability`, requires Pyth data to be available (reverting if not), returns `pythOracle.getPriceNoOlderThan(asset, age)` if only Pyth is available, and calls `_selectLargestDeviation` with results from `pythOracle.getPriceNoOlderThan(asset, age)` and `spotOracle.getPriceNoOlderThan(asset, age)` if both are available. It reads `spotOracle`, `pythOracle`, `asset`, and `age` but modifies no state."
  },
  "RootPriceOracle.priceAvailable": {
    "type": "external",
    "function_name": "priceAvailable(address asset)",
    "analysis_result": "This external view function implements the `priceAvailable` method from the `IPriceOracle` interface. Its purpose is to indicate whether reliable price data is available for a given `asset`. Reliability in this context means Pyth data must be available, aligning with the logic in the `getPrice` family of functions. It initializes a boolean variable `availability` to false. It then checks if the `pythOracle` state variable is set (not the zero address). If `pythOracle` is set, it calls `pythOracle.priceAvailable(asset)` and assigns the result to `availability`. It explicitly does *not* check the availability from the `spotOracle` for the final return value. This function reads the `pythOracle` state variable and the `asset` argument but modifies no state."
  },
  "RootPriceOracle._getAssetAvailability": {
    "type": "internal",
    "function_name": "_getAssetAvailability(address asset)",
    "analysis_result": "This internal view function is a helper used by the public `getPrice` functions (`getPrice`, `getPriceUnsafe`, `getPriceNoOlderThan`) and `priceAvailable`. Its purpose is to check and return the availability status of the given `asset` in both the configured Pyth and Spot oracles. It initializes two boolean variables, `pythAvailable` and `spotAvailable`, to false. It checks if the `pythOracle` state variable is set (not zero address); if so, it calls `pythOracle.priceAvailable(asset)` and sets `pythAvailable` accordingly. Similarly, it checks if `spotOracle` is set; if so, it calls `spotOracle.priceAvailable(asset)` and sets `spotAvailable`. Finally, it returns both `pythAvailable` and `spotAvailable`. This function reads the `pythOracle` and `spotOracle` state variables and the `asset` argument but modifies no state."
  },
  "RootPriceOracle._selectLargestDeviation": {
    "type": "internal",
    "function_name": "_selectLargestDeviation(Data memory pythData, Data memory spotData)",
    "analysis_result": "This internal pure function is a helper used by the public `getPrice` functions (`getPrice`, `getPriceUnsafe`, `getPriceNoOlderThan`) when price data is available from both Pyth and Spot oracles. Its purpose is to compare the prices from the two oracles and select the `Data` struct whose price has the largest absolute deviation from 1 WAD (1e18). It takes two `Data` structs as arguments, `pythData` and `spotData`. As part of its logic, it applies a specific rule: if `spotData.price` is greater than `WAD`, it is capped at `WAD` *only for the deviation calculation* (the original `spotData` struct is not modified for the return value based on this capping logic, only the comparison uses the capped value). It calculates the absolute difference between `spotData.price` (potentially capped) and `WAD`, and the absolute difference between `pythData.price` and `WAD`. It compares these two absolute deviations. If the spot deviation is strictly greater than the pyth deviation, it returns `spotData`; otherwise, it returns `pythData`. This function reads its input arguments (`pythData`, `spotData`) and the `WAD` constant but modifies no state and calls no other contracts."
  },
  "IRootPriceOracle.getPrice": {
    "type": "external",
    "function_name": "getPrice(address token) returns (uint256)",
    "analysis_result": "This function is inherited from the IPriceOracle interface. It is intended to return the price of a specific token identified by its address. As this is an interface, it only defines the function signature and does not contain any implementation logic, storage variable access, or internal calls. Implementing contracts would provide the actual logic for fetching the token price from potentially multiple sources (like spot oracles and Pyth) and would return the price as a uint256. An implementing contract might throw the `UnreliablePrice` error if the price derived is considered unreliable (e.g., solely based on a spot oracle). Events like `SpotOracleSet` and `PythOracleSet` are also defined in this interface and are intended to be emitted by implementing contracts to signal updates to the underlying oracle dependencies that this `getPrice` function might use."
  },
  "IPriceOracle.getPrice": {
    "type": "external view",
    "function_name": "getPrice(address asset) external view returns (Data memory data)",
    "analysis_result": "This external view function is designed to return the current price of a specified asset in USD with WAD precision. It takes one parameter, `asset`, which is the address of the asset. It returns a `Data` struct containing the `price` (uint256) and `publishTime` (uint256). According to the NatSpec, this function is expected to revert if the price data for the given asset has not been recently updated (the definition of 'recently' is implementation-defined). It may also revert with `ZeroAddress` or `UnavailableData(asset)` errors based on the interface definition. As this is an interface, the specific logic for checking recency, retrieving the price, and handling errors is not present; it only defines the function signature and expected behavior."
  },
  "IPriceOracle.getPriceUnsafe": {
    "type": "external view",
    "function_name": "getPriceUnsafe(address asset) external view returns (Data memory data)",
    "analysis_result": "This external view function is designed to return the most recent price update for a specified asset without performing any sanity checks, specifically without checking the recency of the price data. It takes one parameter, `asset`, which is the address of the asset. It returns a `Data` struct containing the `price` (uint256) and `publishTime` (uint256). The NatSpec explicitly states that this function is unsafe because the returned price might be arbitrarily old. Users are cautioned to check the `publishTime` themselves if they need a recent price. It may potentially revert with `ZeroAddress` or `UnavailableData(asset)` errors, though the primary characteristic is the lack of recency checks. As this is an interface, the implementation details are not provided."
  },
  "IPriceOracle.getPriceNoOlderThan": {
    "type": "external view",
    "function_name": "getPriceNoOlderThan(address asset, uint256 age) external view returns (Data memory data)",
    "analysis_result": "This external view function is a safer variant of `getPriceUnsafe`. It is designed to return the price for a specified asset only if the price data is no older than a specified `age` (in seconds) relative to the current time. It takes two parameters: `asset` (the address of the asset) and `age` (the maximum acceptable age of the price data in seconds, uint256). It returns a `Data` struct containing the `price` (uint256) and `publishTime` (uint256). This function reverts if the price data for the asset is older than the specified `age`. This provides a controlled way to get a sufficiently recent price. It may also revert with `ZeroAddress` or `UnavailableData(asset)` errors. As this is an interface, the implementation details, including how recency is checked and how price is retrieved, are not provided."
  },
  "IPriceOracle.priceAvailable": {
    "type": "external view",
    "function_name": "priceAvailable(address asset) external view returns (bool)",
    "analysis_result": "This external view function is a utility function to check if price data is available for a specific asset. It takes one parameter, `asset` (the address of the asset). It returns a boolean value: `true` if price data is available for the asset, and `false` otherwise. This function does not retrieve the price itself, only confirms the existence or availability of data. As this is an interface, the specific logic for determining price availability is not provided."
  },
  "PythPriceOracle.constructor": {
    "type": "constructor",
    "function_name": "constructor()",
    "analysis_result": "This is the constructor for the upgradable contract. It is marked with `/// @custom:oz-upgrades-unsafe-allow constructor` and calls `_disableInitializers()` from the `UUPSUpgradeable` base contract. This prevents the `initialize` function from being called twice during the initial deployment via a proxy. It does not modify any state variables directly. Its primary purpose is part of the OpenZeppelin UUPS upgrade pattern setup."
  },
  "PythPriceOracle.initialize": {
    "type": "external",
    "function_name": "initialize(address governance_)",
    "analysis_result": "This is the main initializer function for the contract, intended to be called once after deployment via an upgradeable proxy. It is marked with the `initializer` modifier, ensuring it can only be called during the initialization process. It requires a `governance_` address as input. It calls `__AccessControl_init()` and `__UUPSUpgradeable_init()` from the inherited OpenZeppelin contracts to set up their respective initialization logic. It then calls the contract's specific initializer `__PriceOracle_init_unchained(governance_)`. It relies on the internal function `__PriceOracle_init_unchained` for the core initialization logic specific to this contract. It doesn't directly access or modify state variables but orchestrates the initialization calls to base contracts and the internal initializer."
  },
  "PythPriceOracle.__PriceOracle_init_unchained": {
    "type": "internal",
    "function_name": "__PriceOracle_init_unchained(address governance_)",
    "analysis_result": "This internal function is called by the `initialize` function and contains the specific initialization logic for the `PythPriceOracle` contract. It uses the `onlyInitializing` modifier, ensuring it can only be called during the initialization phase. It takes `governance_` (an address) as input. It first checks if `governance_` is the zero address; if so, it reverts using `ZeroAddress.selector.revertWith()`. If the address is valid, it grants the `DEFAULT_ADMIN_ROLE` to the `governance_` address using the inherited `_grantRole` function from `AccessControlUpgradeable`. This sets the initial administrator for the contract's access control. It accesses the `DEFAULT_ADMIN_ROLE` constant (inherited) and modifies the internal access control state via `_grantRole`."
  },
  "PythPriceOracle._authorizeUpgrade": {
    "type": "internal",
    "function_name": "_authorizeUpgrade(address newImplementation)",
    "analysis_result": "This internal function is an override required by the `UUPSUpgradeable` pattern. It is called internally by the upgrade mechanism to check if the caller is authorized to perform an upgrade. It takes the address of the `newImplementation` contract as an argument (though it is not used in the current implementation, hence the 'Silent warning' comment). Authorization is granted by checking if the caller possesses the `DEFAULT_ADMIN_ROLE` using the inherited `_checkRole` function from `AccessControlUpgradeable`. If the caller does not have this role, the transaction will revert. It accesses the `DEFAULT_ADMIN_ROLE` constant (inherited) and calls `_checkRole`. It does not modify any state variables."
  },
  "PythPriceOracle.setPythSource": {
    "type": "external",
    "function_name": "setPythSource(address pythOracle_)",
    "analysis_result": "This external function allows setting or changing the address of the underlying Pyth price oracle contract. It requires the caller to have the `DEFAULT_ADMIN_ROLE`, enforced by calling `_checkRole`. It takes the address `pythOracle_` as input. It checks if `pythOracle_` is the zero address; if so, it reverts using `ZeroAddress.selector.revertWith()`. If the address is valid, it updates the state variable `pyth` to the new oracle address. Finally, it emits the `OracleChanged` event with the new oracle address. It accesses the `DEFAULT_ADMIN_ROLE` constant (inherited) and modifies the `pyth` state variable. It calls the internal `_checkRole` function."
  },
  "PythPriceOracle.setPriceFeed": {
    "type": "external",
    "function_name": "setPriceFeed(address asset, bytes32 feed)",
    "analysis_result": "This external function allows setting or changing the Pyth price feed ID associated with a specific asset. It requires the caller to have the `MANAGER_ROLE`, enforced by calling `_checkRole`. It takes the `asset` address and the `feed` ID (bytes32) as input. It checks if the `asset` address is zero, reverting with `ZeroAddress.selector.revertWith()` if true. It also checks if the `feed` ID is zero bytes32, reverting with `ZeroFeed.selector.revertWith()` if true. If inputs are valid, it updates the `feeds` mapping, associating the `asset` address with the provided `feed` ID. It then calls the internal function `getPrice(asset)` as a validation step to ensure the newly set feed is usable (this call will revert if `pyth` is not set or if the feed ID is invalid on the Pyth contract). Finally, it emits the `PriceFeedChanged` event with the asset address and the new feed ID. It accesses the `MANAGER_ROLE` constant and the `feeds` mapping. It modifies the `feeds` mapping. It calls the internal `_checkRole` function and the contract's own `getPrice` function."
  },
  "PythPriceOracle._wrapData": {
    "type": "internal",
    "function_name": "_wrapData(PythStructs.Price memory response)",
    "analysis_result": "This internal pure function is a utility to convert a Pyth-specific price structure (`PythStructs.Price`) into the generic price data structure (`IPriceOracle.Data`) defined by the `IPriceOracle` interface. It takes a `response` object containing price and exponent. It uses `PythUtils.convertToUint` to scale the price value to 18 decimal places (standard ERC20 decimals). It then creates and returns an `IPriceOracle.Data` struct containing the converted price and the original publish time from the Pyth response. It does not access or modify any state variables. It calls `PythUtils.convertToUint` (from the imported library)."
  },
  "PythPriceOracle.getPrice": {
    "type": "public",
    "function_name": "getPrice(address asset) returns (struct IPriceOracle.Data data)",
    "analysis_result": "This public view function implements the `getPrice` method from the `IPriceOracle` interface. It takes an `asset` address as input and returns a `Data` struct containing the price and publish time. It first calls the internal `_pythAndFeedAreSet(asset)` function to check if the `pyth` oracle address and the price feed for the given `asset` are both set. If either is not set, it reverts with `UnavailableData.selector.revertWith(asset)`. If the oracle and feed are set, it calls the `getPrice(bytes32)` method on the underlying `pyth` contract, passing the feed ID stored in `feeds[asset]`. The result from the Pyth oracle (a `PythStructs.Price`) is then passed to the internal `_wrapData` function to convert it into the contract's `IPriceOracle.Data` format before being returned. It accesses the `pyth` state variable and the `feeds` mapping. It calls the internal `_pythAndFeedAreSet` function, the external `pyth.getPrice` function, and the internal `_wrapData` function."
  },
  "PythPriceOracle.getPriceUnsafe": {
    "type": "public",
    "function_name": "getPriceUnsafe(address asset) returns (struct IPriceOracle.Data data)",
    "analysis_result": "This public view function implements the `getPriceUnsafe` method from the `IPriceOracle` interface. It takes an `asset` address as input and returns a `Data` struct containing the price and publish time. It is similar to `getPrice` but calls `pyth.getPriceUnsafe` which might return a price even if it's slightly outdated, depending on the Pyth oracle's implementation. It first checks if `pyth` and `feeds[asset]` are set using `_pythAndFeedAreSet(asset)`. If not, it reverts with `UnavailableData.selector.revertWith(asset)`. If set, it calls the `getPriceUnsafe(bytes32)` method on the underlying `pyth` contract with the feed ID `feeds[asset]`. The result is wrapped into `IPriceOracle.Data` using `_wrapData` and returned. It accesses the `pyth` state variable and the `feeds` mapping. It calls the internal `_pythAndFeedAreSet` function, the external `pyth.getPriceUnsafe` function, and the internal `_wrapData` function."
  },
  "PythPriceOracle.getPriceNoOlderThan": {
    "type": "external",
    "function_name": "getPriceNoOlderThan(address asset, uint256 age) returns (struct IPriceOracle.Data data)",
    "analysis_result": "This external view function implements the `getPriceNoOlderThan` method from the `IPriceOracle` interface. It takes an `asset` address and a maximum `age` (in seconds) for the price data. It returns a `Data` struct. It first checks if `pyth` and `feeds[asset]` are set using `_pythAndFeedAreSet(asset)`. If not, it reverts with `UnavailableData.selector.revertWith(asset)`. If set, it calls the `getPriceNoOlderThan(bytes32, uint64)` method on the underlying `pyth` contract, passing the feed ID `feeds[asset]` and the `age`. This function on the Pyth oracle will revert if the most recent price is older than the specified age. The result from the Pyth oracle is wrapped into `IPriceOracle.Data` using `_wrapData` and returned. It accesses the `pyth` state variable and the `feeds` mapping. It calls the internal `_pythAndFeedAreSet` function, the external `pyth.getPriceNoOlderThan` function, and the internal `_wrapData` function."
  },
  "PythPriceOracle.priceAvailable": {
    "type": "external",
    "function_name": "priceAvailable(address asset) returns (bool)",
    "analysis_result": "This external view function implements the `priceAvailable` method from the `IPriceOracle` interface. It takes an `asset` address and returns a boolean indicating whether a price is available for that asset. It first calls the internal `_pythAndFeedAreSet(asset)` function to check if the `pyth` oracle and the feed for the `asset` are set in this contract. If either is not set, it immediately returns `false`. If both are set, it proceeds to call the contract's own `getPriceUnsafe(asset)` function. It then checks the `publishTime` field of the returned `Data` struct. If `publishTime` is not zero, it considers the price available and returns `true`; otherwise, it returns `false`. Accesses the `pyth` state variable and the `feeds` mapping. It calls the internal `_pythAndFeedAreSet` function and the contract's own `getPriceUnsafe` function."
  },
  "PythPriceOracle._pythAndFeedAreSet": {
    "type": "internal",
    "function_name": "_pythAndFeedAreSet(address asset) returns (bool)",
    "analysis_result": "This internal view function is a helper used by the price retrieval functions (`getPrice`, `getPriceUnsafe`, `getPriceNoOlderThan`, `priceAvailable`) to check if the contract is properly configured to provide a price for a given asset. It takes an `asset` address. It checks two conditions: 1) if the `pyth` state variable (the Pyth oracle address) is the zero address. If it is, it returns `false`. 2) if the entry for the `asset` in the `feeds` mapping is the zero bytes32 value. If it is, it returns `false`. Only if *both* the `pyth` address and the `feeds[asset]` feed ID are non-zero does the function return `true`, indicating that the necessary setup is in place. It accesses the `pyth` state variable and the `feeds` mapping. It does not call any other functions or modify state."
  },
  "RootPriceOracleDeployer.constructor": {
    "type": "constructor",
    "function_name": "constructor(address governance, uint256 salt)",
    "analysis_result": "This is the constructor for the RootPriceOracleDeployer contract. Its purpose is to deploy the RootPriceOracle contract using CREATE2 and then initialize it. It takes two parameters: `governance`, an address used for initialization, and `salt`, a unique value used by the CREATE2 opcode. Inside the constructor, it calls the inherited function `deployWithCreate2`, passing the provided `salt` and the creation bytecode of the RootPriceOracle contract (`type(RootPriceOracle).creationCode`). The address returned by `deployWithCreate2` (which is the address of the newly deployed RootPriceOracle contract) is stored in the `rootPriceOracle` state variable. Finally, it calls the `initialize` function on the newly deployed `rootPriceOracle` contract, passing the `governance` address provided to the constructor. This initializes the RootPriceOracle contract with the specified governance address. This constructor modifies the `rootPriceOracle` state variable."
  }
}